In một số nguyên ở định dạng nhị phân trong Java

Tôi có một số và tôi muốn in nó ở dạng nhị phân. Tôi không muốn làm điều đó bằng cách viết một thuật toán, Có hàm tích hợp nào cho Java không?

Giả sử bạn có nghĩa là "tích hợp":

int x = 100;
System.out.println(Integer.toBinaryString(x));

Xem tài liệu Integer .

( Longcó một phương thức tương tự, BigIntegercó một phương thức cá thể trong đó bạn có thể chỉ định cơ số.)

Ở đây không cần chỉ phụ thuộc vào nhị phân hoặc bất kỳ định dạng nào khác ... có sẵn một chức năng linh hoạt được in sẵn. Nó in bất kỳ định dạng nào bạn muốn trong chương trình của mình .. Integer.toString (int, đại diện);

Integer.toString(100,8) // prints 144 --octal representation

Integer.toString(100,2) // prints 1100100 --binary representation

Integer.toString(100,16) //prints 64 --Hex representation

System.out.println(Integer.toBinaryString(343));

Tôi cần một cái gì đó để in mọi thứ độc đáo và tách các bit mỗi n-bit. Nói cách khác, hiển thị các số 0 đứng đầu và hiển thị một cái gì đó như thế này:

n = 5463
output = 0000 0000 0000 0000 0001 0101 0101 0111

Vì vậy, đây là những gì tôi đã viết:

/**
 * Converts an integer to a 32-bit binary string
 * @param number
 *      The number to convert
 * @param groupSize
 *      The number of bits in a group
 * @return
 *      The 32-bit long bit string
 */
public static String intToString(int number, int groupSize) {
    StringBuilder result = new StringBuilder();

    for(int i = 31; i >= 0 ; i--) {
        int mask = 1 << i;
        result.append((number & mask) != 0 ? "1" : "0");

        if (i % groupSize == 0)
            result.append(" ");
    }
    result.replace(result.length() - 1, result.length(), "");

    return result.toString();
}

Gọi nó như thế này:

public static void main(String[] args) {
    System.out.println(intToString(5463, 4));
}

Trường cũ:

    int value = 28;
    for(int i = 1, j = 0; i < 256; i = i << 1, j++)
        System.out.println(j + " " + ((value & i) > 0 ? 1 : 0));

public static void main(String[] args) 
{
    int i = 13;
    short s = 13;
    byte b = 13;

    System.out.println("i: " + String.format("%32s", 
            Integer.toBinaryString(i)).replaceAll(" ", "0"));

    System.out.println("s: " + String.format("%16s", 
            Integer.toBinaryString(0xFFFF & s)).replaceAll(" ", "0"));

    System.out.println("b: " + String.format("%8s", 
            Integer.toBinaryString(0xFF & b)).replaceAll(" ", "0"));

}

Đầu ra:

i: 00000000000000000000000000001101
s: 0000000000001101
b: 00001101

kiểm tra logic này có thể chuyển đổi một số sang bất kỳ cơ sở

public static void toBase(int number, int base) {
    String binary = "";
    int temp = number/2+1;
    for (int j = 0; j < temp ; j++) {
        try {
            binary += "" + number % base;

            number /= base;
        } catch (Exception e) {
        }
    }
    for (int j = binary.length() - 1; j >= 0; j--) {
        System.out.print(binary.charAt(j));
    }
}

HOẶC LÀ

StringBuilder binary = new StringBuilder();
int n=15;
while (n>0) {
    if((n&1)==1){
        binary.append(1);
    }else
        binary.append(0);
    n>>=1;
}
System.out.println(binary.reverse());

Đây là cách đơn giản nhất để in biểu diễn nhị phân bên trong của một số nguyên. Ví dụ : Nếu chúng ta lấy n là 17 thì đầu ra sẽ là: 0000 0000 0000 0000 0000 0000 0001 0001

void bitPattern(int n) {

        int mask = 1 << 31;
        int count = 0;
        while(mask != 0) {
            if(count%4 == 0)
                System.out.print(" ");

            if((mask&n) == 0) 

                System.out.print("0");



            else 
                System.out.print("1");


            count++;
            mask = mask >>> 1;


    }
    System.out.println();
}

Đơn giản hãy thử nó. Nếu phạm vi chỉ in các giá trị nhị phân của giá trị nguyên đã cho. Nó có thể là tích cực hoặc tiêu cực.

      public static void printBinaryNumbers(int n) {
        char[] arr = Integer.toBinaryString(n).toCharArray();
        StringBuilder sb = new StringBuilder();
        for (Character c : arr) {
          sb.append(c);
        }
        System.out.println(sb);
      }

đầu vào

5

Đầu ra

101

Giải pháp sử dụng mặt nạ hiển thị 32 bit,

public static String toBinaryString(int n){

    StringBuilder res=new StringBuilder();
    //res= Integer.toBinaryString(n); or
    int displayMask=1<<31;
    for (int i=1;i<=32;i++){
        res.append((n & displayMask)==0?'0':'1');
        n=n<<1;
        if (i%8==0) res.append(' ');
    }

    return res.toString();
}


 System.out.println(BitUtil.toBinaryString(30));


O/P:
00000000 00000000 00000000 00011110 

Giải pháp đơn giản và khá dễ dàng.

public static String intToBinaryString(int integer, int numberOfBits) {

    if (numberOfBits > 0) {     // To prevent FormatFlagsConversionMismatchException.

        String nBits = String.format("%" + numberOfBits + "s",      // Int to bits conversion
                Integer.toBinaryString(integer))
                .replaceAll(" ","0"); 

        return nBits;   // returning the Bits for the given int.
    }

    return null;        // if the numberOfBits is not greater than 0, returning null.
}

Đã có câu trả lời tốt được đăng ở đây cho câu hỏi này. Nhưng, đây là cách tôi đã thử bản thân mình (và có thể là logic dễ nhất dựa trên → modulo / chia / thêm ):

        int decimalOrBinary = 345;
        StringBuilder builder = new StringBuilder();

        do {
            builder.append(decimalOrBinary % 2);
            decimalOrBinary = decimalOrBinary / 2;
        } while (decimalOrBinary > 0);

        System.out.println(builder.reverse().toString()); //prints 101011001

Câu hỏi là khó trong java (và có lẽ trong ngôn ngữ khác).

Số nguyên là loại dữ liệu được ký 32 bit , nhưng Integer.toBinaryString () trả về một chuỗi đại diện của đối số nguyên dưới dạng một số nguyên không dấu trong cơ sở 2.

Vì vậy, Integer.parseInt (Integer.toBinaryString (X), 2) có thể tạo ra một ngoại lệ (được ký so với không dấu).

Cách an toàn là sử dụng Integer.toString (X, 2); điều này sẽ tạo ra một cái gì đó kém thanh lịch:

-11110100110

Nhưng nó đã có tác dụng!!!

Tôi nghĩ đó là thuật toán đơn giản nhất cho đến nay (đối với những người không muốn sử dụng các hàm dựng sẵn):

public static String convertNumber(int a)  { 
              StringBuilder sb=new StringBuilder();
              sb.append(a & 1);
              while ((a>>=1) != 0)  { 
                  sb.append(a & 1);
               }
              sb.append("b0");
              return sb.reverse().toString();
  }

Thí dụ:

chuyển đổiSố (1) -> "0b1"

chuyển đổiSố (5) -> "0b101"

chuyển đổiSố (117) -> "0b1110101"

Cách thức hoạt động: while-loop di chuyển một số sang phải (thay thế bit cuối cùng bằng thứ hai đến cuối cùng, v.v.), lấy giá trị của bit cuối cùng và đặt nó vào StringBuilder, lặp lại cho đến khi không còn bit nào (đó là khi a = 0).

    for(int i = 1; i <= 256; i++)
    {
        System.out.print(i + " "); //show integer
        System.out.println(Integer.toBinaryString(i) + " "); //show binary
        System.out.print(Integer.toOctalString(i) + " "); //show octal
        System.out.print(Integer.toHexString(i) + " "); //show hex

    }

Hãy thử cách này:

public class Bin {
  public static void main(String[] args) {
    System.out.println(toBinary(0x94, 8));
  }

  public static String toBinary(int a, int bits) {
    if (--bits > 0)
        return toBinary(a>>1, bits)+((a&0x1)==0?"0":"1");
    else 
        return (a&0x1)==0?"0":"1";
  }

}

10010100

Biểu diễn nhị phân của int x đã cho với các số 0 được đệm trái:

org.apache.commons.lang3.StringUtils.leftPad(Integer.toBinaryString(x), 32, '0')

Nhập bất kỳ số thập phân nào làm đầu vào. Sau đó, chúng tôi hoạt động như modulo và phân chia để chuyển đổi đầu vào đã cho thành số nhị phân. Dưới đây là mã nguồn của Chương trình Java để chuyển đổi các giá trị số nguyên thành nhị phân và số bit của nhị phân này cho số thập phân của anh ta. Chương trình Java được biên dịch thành công và chạy trên hệ thống Windows. Đầu ra chương trình cũng được hiển thị dưới đây.

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int integer ;
        String binary = "";    //   here we count "" or null 
                               //   just String binary = null;
        System.out.print("Enter the binary Number: ");
        integer = sc.nextInt();

        while(integer>0)
        {
            int x = integer % 2;
            binary = x + binary;
            integer = integer / 2;  
        }
        System.out.println("Your binary number is : "+binary);
        System.out.println("your binary length : " + binary.length());
    }
}

Vì không có câu trả lời nào được chấp nhận, có lẽ câu hỏi của bạn là về cách lưu trữ một số nguyên trong tệp nhị phân. java.io.DataOutputStream có thể là những gì bạn đang tìm kiếm: https://docs.oracle.com/javase/8/docs/api/java/io/DataOutputStream.html

DataOutputStream os = new DataOutputStream(outputStream);
os.writeInt(42);
os.flush();
os.close();

Bạn có thể sử dụng mặt nạ bit (1 << k) và thực hiện thao tác AND với số! 1 << k có một bit ở vị trí k!

private void printBits(int x) {
    for(int i = 31; i >= 0; i--) {
        if((x & (1 << i)) != 0){
            System.out.print(1);
        }else {
            System.out.print(0);
        }
    }
    System.out.println();
}

Nó hoạt động với các giá trị được ký và không dấu được sử dụng thao tác bit mạnh mẽ và tạo ra các số 0 đầu tiên bên trái.

public static String representDigits(int num) {

        int checkBit = 1 << (Integer.SIZE * 8 - 2 );    // avoid the first digit        
        StringBuffer sb = new StringBuffer();

        if (num < 0 ) {     // checking the first digit
            sb.append("1");
        } else {
            sb.append("0");
        }

        while(checkBit != 0) {          
            if ((num & checkBit) == checkBit){
                sb.append("1");
            } else {
                sb.append("0");
            }           
            checkBit >>= 1;     
        }       

        return sb.toString();
    }