Làm thế nào để có được đại diện nhị phân 0-đệm của một số nguyên trong java?

Question

ví dụ, cho 1, 2, 128, 256 đầu ra có thể được (16 chữ số):

0000000000000001 
0000000000000010 
0000000010000000 
0000000100000000 

tôi đã cố gắng

String.format("%16s", Integer.toBinaryString(1)); 

nó đặt chỗ cho trái padding:

`    1' 

Làm thế nào để đưa 0 s để đệm. Tôi không thể tìm thấy nó trong Formatter. Có cách nào khác để làm điều đó không?

Xin cảm ơn trước.

P.S. this post mô tả cách định dạng số nguyên với phần đệm 0 trái, nhưng nó không phải là biểu diễn nhị phân.

Answer 1

Tôi nghĩ rằng đây là một giải pháp tối ưu, nhưng bạn có thể làm

String.format("%16s", Integer.toBinaryString(1)).replace(' ', '0') 

Answer 2

thử ...

String.format("%016d\n", Integer.parseInt(Integer.toBinaryString(256))); 

Tôi không nghĩ rằng đây là "đúng" cách để làm điều này ... nhưng nó hoạt động :)

Answer 3

Không có chuyển đổi nhị phân nào được tích hợp vào java.util.Formatter, tôi khuyên bạn nên sử dụng String.replace để thay thế ký tự không gian bằng số 0, như sau:

String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0") 

Hoặc thực hiện logic của riêng bạn để chuyển đổi số nguyên thành biểu diễn nhị phân có thêm đệm trái ở đâu đó dọc theo các dòng được đưa ra trong this như vậy. Hoặc nếu bạn thực sự cần phải vượt qua con số để định dạng, bạn có thể chuyển đổi biểu diễn nhị phân của bạn để BigInteger và sau đó định dạng mà với số không hàng đầu, nhưng điều này là rất tốn kém trong thời gian chạy, như trong:

String.format("%016d", new BigInteger(Integer.toBinaryString(1))) 

Answer 4

Tôi không biết giải pháp "đúng" nhưng tôi có thể đề xuất cho bạn một bản vá nhanh.

String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0"); 

Tôi vừa thử và thấy nó hoạt động tốt.

Answer 5

Tôi đã thử tất cả các loại cuộc gọi phương thức mà trước đây tôi chưa thực sự sử dụng để thực hiện công việc này, họ đã làm việc với thành công vừa phải, cho đến khi tôi nghĩ về điều gì đó đơn giản đến mức nó có thể hoạt động.

Tôi chắc chắn nó đã được nghĩ đến trước đây, không chắc chắn nếu nó tốt cho chuỗi dài của mã nhị phân nhưng nó hoạt động tốt cho chuỗi 16Bit. Hy vọng nó giúp!! (Lưu ý đoạn mã thứ hai được cải thiện)

String binString = Integer.toBinaryString(256); 
    while (binString.length() < 16) { //pad with 16 0's 
     binString = "0" + binString; 
    } 

Nhờ có giúp cải thiện câu trả lời này để làm cho nó hoạt động trong vòng lặp. Đây có thể là một chút vụng về nhưng nó hoạt động, xin vui lòng cải thiện và bình luận trở lại nếu bạn có thể ....

binString = Integer.toBinaryString(256); 
int length = 16 - binString.length(); 
char[] padArray = new char[length]; 
Arrays.fill(padArray, '0'); 
String padString = new String(padArray); 
binString = padString + binString; 

Answer 6

Bạn có thể sử dụng Apache Commons StringUtils.Nó cung cấp phương pháp cho chuỗi padding:

StringUtils.leftPad(Integer.toBinaryString(1), 16, '0'); 

Answer 7

Đây là một thủ thuật cũ, tạo ra một chuỗi với 16 0 của sau đó nối các chuỗi nhị phân tỉa bạn nhận được từ String.format ("% s", Integer.toBinaryString (1)) và sử dụng tối đa 16 ký tự nhất, băm nhỏ bất kỳ số 0 hàng đầu nào. Tốt hơn, hãy tạo một hàm cho phép bạn chỉ định thời gian của chuỗi nhị phân bạn muốn. Tất nhiên có thể là một bazillion cách khác để thực hiện điều này bao gồm thư viện, nhưng tôi thêm bài này để giúp đỡ một người bạn :)

public class BinaryPrinter { 

    public static void main(String[] args) { 
     System.out.format("%d in binary is %s\n", 1, binaryString(1, 4)); 
     System.out.format("%d in binary is %s\n", 128, binaryString(128, 8)); 
     System.out.format("%d in binary is %s\n", 256, binaryString(256, 16)); 
    } 

    public static String binaryString(final int number, final int binaryDigits) { 
     final String pattern = String.format("%%0%dd", binaryDigits); 
     final String padding = String.format(pattern, 0); 
     final String response = String.format("%s%s", padding, Integer.toBinaryString(number)); 

     System.out.format("\npattern = '%s'\npadding = '%s'\nresponse = '%s'\n\n", pattern, padding, response); 

     return response.substring(response.length() - binaryDigits); 
    } 
} 

Answer 8

Một phiên bản đơn giản của ý tưởng user3608934 của "Đây là một thủ thuật cũ, tạo một chuỗi có 16 0 sau đó nối thêm chuỗi nhị phân đã cắt mà bạn nhận được ":

private String toBinaryString32(int i) { 
    String binaryWithOutLeading0 = Integer.toBinaryString(i); 
    return "00000000000000000000000000000000" 
      .substring(binaryWithOutLeading0.length()) 
      + binaryWithOutLeading0; 
} 

Answer 9

Đây là câu trả lời mới cho bài đăng cũ.

Để pad một giá trị nhị phân với số không dẫn đến một độ dài cụ thể, hãy thử này:

Integer.toBinaryString((1 << len) | val).substring(1) 

Nếu len = 4 và val = 1,

Integer.toBinaryString((1 << len) | val) 

lợi nhuận chuỗi "10001", sau đó

"10001".substring(1) 

loại bỏ ký tự đầu tiên. Vì vậy, chúng ta có được những gì chúng ta muốn:

"0001" 

Nếu val có khả năng là tiêu cực, thay vì cố gắng:

Integer.toBinaryString((1 << len) | (val & ((1 << len) - 1))).substring(1) 

Answer 10

Tôi sẽ viết lớp util của riêng tôi với phương pháp này như dưới đây

public class NumberFormatUtils { 

public static String longToBinString(long val) { 
    char[] buffer = new char[64]; 
    Arrays.fill(buffer, '0'); 
    for (int i = 0; i < 64; ++i) { 
     long mask = 1L << i; 
     if ((val & mask) == mask) { 
      buffer[63 - i] = '1'; 
     } 
    } 
    return new String(buffer); 
} 

public static void main(String... args) { 
    long value = 0b0000000000000000000000000000000000000000000000000000000000000101L; 
    System.out.println(value); 
    System.out.println(Long.toBinaryString(value)); 
    System.out.println(NumberFormatUtils.longToBinString(value)); 
} 

}

Đầu ra:

 
5 
101 
0000000000000000000000000000000000000000000000000000000000000101 

Phương pháp tương tự có thể áp dụng cho mọi loại tích phân. Chú ý đến các loại mặt nạ

long mask = 1L << i;

Answer 11

Phương pháp này chuyển đổi một int vào một String, chiều dài = bit. Hoặc đệm với 0 hoặc với các bit quan trọng nhất cắt ngắn.

static String toBitString(int x, int bits){ 
    String bitString = Integer.toBinaryString(x); 
    int size = bitString.length(); 
    StringBuilder sb = new StringBuilder(bits); 
    if(bits > size){ 
     for(int i=0; i<bits-size; i++) 
      sb.append('0'); 
     sb.append(bitString); 
    }else 
     sb = sb.append(bitString.substring(size-bits, size)); 

    return sb.toString(); 
} 

Answer 12

Một giải pháp ngây thơ mà làm việc sẽ là

String temp = Integer.toBinaryString(5); 
while (temp.length() < Integer.SIZE) temp = "0"+temp; //pad leading zeros 
temp = temp.substring(Integer.SIZE - Short.SIZE); //remove excess 

Một phương pháp khác sẽ là

String temp = Integer.toBinaryString((m | 0x80000000)); 
temp = temp.substring(Integer.SIZE - Short.SIZE); 

này sẽ tạo ra một chuỗi 16 bit của số nguyên 5

Answer 13

Bạn có thể sử dụng lib https://github.com/kssource/BitSequence. Nó chấp nhận một số và trả về chuỗi bynary, đệm và/hoặc nhóm lại.

String s = new BitSequence(2, 16).toBynaryString(ALIGN.RIGHT, GROUP.CONTINOUSLY)); 
return 
0000000000000010 

another examples: 

[10, -20, 30]->00001010 11101100 00011110 
i=-10->00000000000000000000000000001010 
bi=10->1010 
sh=10->00 0000 0000 1010 
l=10->00000001 010 
by=-10->1010 
i=-10->bc->11111111 11111111 11111111 11110110 

Answer 14

for(int i=0;i<n;i++) 
{ 
    for(int j=str[i].length();j<4;j++) 
    str[i]="0".concat(str[i]); 
} 

str[i].length() là chiều dài của số nói 2 trong hệ nhị phân là 01 mà là chiều dài 2 thay đổi từ 4 đến mong muốn chiều dài tối đa của số. Điều này có thể được tối ưu hóa cho O (n). bằng cách sử dụng tiếp tục.