如何在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）。 继续。