如何在Java中获取整数的0填充二进制表示形式？

例如，对于1, 2, 128, 256输出可以是（16位）：

0000000000000001
0000000000000010
0000000010000000
0000000100000000

我试过了

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

它为左填充留出空间：

`               1'

如何将0s用作填充。我在Formatter中找不到它。还有另一种方法吗？

PS 这篇文章描述了如何使用左0填充来格式化整数，但不适用于二进制表示形式。

我认为这是次优的解决方案，但是您可以

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

java.util.Formatter中没有内置二进制转换，我建议您使用String.replace将空格字符替换为零，如下所示：

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

或者实现你自己的逻辑来将整数与沿指定的行加左填充的地方二进制表示该如此。或者，如果您确实需要传递数字以进行格式化，则可以将二进制表示形式转换为BigInteger，然后使用前导零进行格式化，但这在运行时非常昂贵，例如：

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

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

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

我一直在尝试各种方法调用，这些方法调用在我之前从未真正使用过，但都取得了一定的成功，直到我想到如此简单的东西才可能奏效，并且确实做到了！

我确定以前已经考虑过它了，不确定它是否对长字符串的二进制代码有好处，但是对于16Bit字符串却可以正常工作。希望能帮助到你！！（注意第二段代码已改进）

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;

这是旧帖子的新答案。

要将前导零填充为特定长度的二进制值，请尝试以下操作：

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 )

user3608934的想法的简单版本：“这是一个老把戏，创建一个带有16 0的字符串，然后附加修剪后的二进制字符串”：

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

我不知道“正确的”解决方案，但我可以建议您快速修补。

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

我刚刚尝试了一下，发现效果很好。

尝试...

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

我不认为这是执行此操作的“正确”方法...但是它有效:)

一个天真的解决方案是

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

这将产生16位整数5的字符串

从Java 11开始，您可以使用 repeat（...）方法：

"0".repeat(Integer.numberOfLeadingZeros(i) - 16) + Integer.toBinaryString(i)

或者，如果您需要32位表示形式的任何整数：

"0".repeat(Integer.numberOfLeadingZeros(i != 0 ? i : 1)) + Integer.toBinaryString(i)

这是一个古老的技巧，创建一个带有16 0的字符串，然后附加从String.format（“％s”，Integer.toBinaryString（1））中获得的修剪后的二进制字符串，并使用最右边的16个字符，从而忽略所有前导0。更好的是，创建一个函数，让您指定所需的二进制字符串长度。当然，可能还有数不胜数的其他方法可以做到这一点，包括库，但是我要添加这篇文章来帮助一位朋友:)

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

我将使用如下方法编写自己的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
0000000000000000000000000000000000000000000000000000000000000000000000000000000101

相同的方法可以应用于任何整数类型。注意口罩的类型

long mask = 1L << i;

此方法将int转换为String，长度=位。用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();
}

您可以使用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

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中的2是01，这是长度2将4更改为所需的最大数字长度。可以将其优化为O（n）。通过使用继续。

//下面将处理适当的大小

public static String binaryString(int i) {
    return String.format("%" + Integer.SIZE + "s", Integer.toBinaryString(i)).replace(' ', '0');
}

public static String binaryString(long i) {
    return String.format("%" + Long.SIZE + "s", Long.toBinaryString(i)).replace(' ', '0');
}

import java.util.Scanner;
public class Q3{
  public static void main(String[] args) {
    Scanner scn=new Scanner(System.in);
    System.out.println("Enter a number:");
    int num=scn.nextInt();
    int numB=Integer.parseInt(Integer.toBinaryString(num));
    String strB=String.format("%08d",numB);//makes a 8 character code
    if(num>=1 && num<=255){
     System.out.println(strB);
    }else{
        System.out.println("Number should be in range between 1 and 255");
    }
  }
}