如何在java中獲得0填充二進制表示的整數？

Question

例如，爲1, 2, 128, 256輸出可以是（16位）：

0000000000000001 
0000000000000010 
0000000010000000 
0000000100000000 

我試圖

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

它把空間的左填充：

`    1' 

如何把0 s用於填充。我在Formatter找不到它。還有另一種方法可以做到嗎？

在此先感謝。

P.S. this post描述瞭如何用左0填充格式整數，但它不適用於二進製表示。

Answer 1

我認爲這是一個次優的解決方案，但你可以做

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

Answer 2

試...

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

我不認爲這是「正確」的方式來這樣做...但它的工作原理:)

Answer 3

沒有內置到java.util.Formatter中的二進制轉換，我建議您使用String.replace替換空格字符爲零，如下所示：

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

或者實現您自己的邏輯，將整數轉換爲二進制表示形式，並在this中給出的行中添加左填充符。 或者，如果你真的需要通過號碼格式，您可以將您的二進制表示形式轉換爲BigInteger和再格式化帶前導零，但是這是在運行時非常昂貴，如：

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

Answer 4

我不知道「正確」的解決方案，但我可以建議你一個快速補丁。

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

我剛剛試過，看到它工作正常。

Answer 5

我嘗試了各種方法的調用我還沒有真正使用之前，使這項工作，他們的工作有一定的成功，直到我想到的東西是如此簡單，它可能只是工作，不是沒有！

我敢肯定，它已經想到過，如果不知道它的任何好的二進制碼長字符串，但對於16位的字符串工作正常。希望能幫助到你！！ （注意第二段代碼得到了改進）

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

感謝Will幫助改進這個答案，使它與循環一起工作。 這也許有點笨拙，但它的工作原理，請提高和評論回來，如果你能....

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

您可以使用Apache的百科全書StringUtils。它提供了方法填充字符串：

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

Answer 7

這是一個老把戲，創建一個字符串與16 0的然後附加你的String.format（「％S」，Integer.toBinaryString得到了修整二進制字符串（1） ）並使用最右邊的16個字符，從而消除任何前導0。更好的是，創建一個函數，讓您指定需要多長時間的二進制字符串。當然也有可能是其他bazillion的方式來做到這一點，包括圖書館，但我加入這個職位，以幫助朋友:)

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

user3608934的想法的一個簡化版本「這是一個老把戲，創建一個帶有16個0的字符串然後附加你得到的修剪的二進制串「：

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

Answer 9

這裏是一箇舊帖子的新答案。

爲了用前導零到特定長度的二進制值，試試這個：

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

如果len = 4和val = 1，

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

返回字符串"10001"，然後

"10001".substring(1) 

丟棄了第一個字符。所以，我們得到我們想要的東西：

"0001" 

如果val很可能是負的，而嘗試：

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

Answer 10

我會寫我自己的util類的方法，如下面

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)); 
} 

}

輸出：

 
5 
101 
0000000000000000000000000000000000000000000000000000000000000101 

同樣的方法可以應用於任何整型。注意掩模

long mask = 1L << i;

Answer 11

此方法一個int轉換爲字符串，長度=比特的類型。填充0或截斷最重要的位。

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

該工作幼稚的解決辦法是

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 

另外一個方法是

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

這將產生整數5

Answer 13

你可以的一個16位的串使用lib https://github.com/kssource/BitSequence。它接受一個數字並返回字符串，填充和/或分組。

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()是數的長度說2二進制是01，其是長度爲2 變化4〜數目的所希望的最大長度。這可以優化爲O（n）。 繼續。