如何在java中获得整数的0填充二进制表示？

例如，对于

1、2、128、256

，输出可以是（16位）：

我试过了

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

它为左填充留出空间：

`               1'

如何放置

0

s进行填充。我在里面找不到它。还有别的办法吗

---

p.S.介绍了如何使用左0填充设置整数格式，但它不适用于二进制表示。

我认为这是一个次优解决方案，但您可以这样做

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

试试看

---

我不认为这是做这件事的“正确”方式。。。但是它是有效的：）

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

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

或者实现您自己的逻辑，将整数转换为二进制表示，并在so中给出的行中添加左填充。 或者，如果确实需要将数字传递到格式，则可以将二进制表示形式转换为BigInteger，然后使用前导零对其进行格式设置，但这在运行时非常昂贵，如：

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

我不知道“正确”的解决方案，但我可以建议你一个快速补丁

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

---

我刚刚试过，发现它工作得很好。

我尝试了各种方法调用，我以前没有真正使用过这些方法来实现这一点，它们都取得了一定的成功，直到我想到了一种非常简单的方法，它可能会工作，它确实做到了

我相信这是以前考虑过的，不确定它是否适用于长字符串的二进制代码，但它适用于16位字符串。希望能有帮助！！（注意第二段代码得到了改进）

---

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

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

---

这是一个老把戏，创建一个16个0的字符串，然后附加从string.format（“%s”，Integer.toBinaryString（1））中获得的修剪过的二进制字符串，并使用最右边的16个字符，删除任何前导的0。更好的是，制作一个函数，让您指定所需的二进制字符串的长度。当然，可能还有无数其他方法可以实现这一点，包括图书馆，但我添加这篇文章是为了帮助一位朋友：）

---

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

---

这里有一个旧帖子的新答案

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

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

返回字符串

“10001”

，然后

"10001".substring( 1 )

丢弃第一个字符。因此，我们获得了我们想要的：

"0001"

如果

val

可能为负值，请尝试：

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

---

Integer.tobinarysting（（1我会用下面的方法编写自己的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));
}

公共类编号格式{
公共静态字符串longToBinString（long val）{
char[]buffer=新字符[64]；
数组。填充（缓冲区，'0'）；
对于（int i=0；i<64；++i）{
long mask=1L此方法将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();
}

静态字符串到字符串（整数x，整数位）{
字符串bitString=Integer.toBinaryString（x）；
int size=bitString.length（）；
StringBuilder sb=新的StringBuilder（位）；
如果（位>大小）{
对于（inti=0；i来说，这是一个简单的解决方案

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

这将产生一个16位的整数5字符串，您可以使用lib。它接受一个数字并返回按位字符串、填充和/或分组

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（inti=0；i//下面将处理适当的大小

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；
公开课Q3{
公共静态void main（字符串[]args）{
扫描仪scn=新扫描仪（System.in）；
System.out.println（“输入一个数字：”）；
int num=scn.nextInt（）；
int numB=Integer.parseInt（Integer.toBinaryString（num））；
String strB=String.format（“%08d”，numB）；//生成一个8个字符的代码
如果（num>=1&&num从Java 11开始，则可以使用以下方法：

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

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

你试过使用
%016s
？@Deniz是的，它失败了，线程“main”java.util.FormatFlagsConversionMismatchException:Conversion=s，Flags=0
看看这个：是的，我现在就这么做了，但我相信应该有另一种方法：）谢谢。事实上，在做了一些研究之后，看起来仅仅使用printf语法是做不到的。因此，也许它还不算太糟。@Daniel负数不包含任何空格，所以它也可以工作。@Daniel Integer:：toBinaryString doc:
将整数参数的字符串表示形式作为基数2中的无符号整数返回。
Thanks、 这一个更好，因为它避免了对大数字（例如2^30）的溢出。是的，但我真的不会这样做，我会使用replace方法或我自己的填充方法：一种方法是再次使用String.format以参数零格式化所需的填充长度，或者在代码中使用String.format（“%0”+（32-binary.length（））+“d”%s“，0，binary）当然，您需要注意32-binary.length（）的负面结果……这是一个很好且简单的解决方案。它可以通过使用
binString.length（）之间的差异来改进
和16创建一个字符串，然后将该字符串附加到binString，而不是像这样循环回答：威尔-你太棒了，我现在就把它放在我的代码中！我也不喜欢循环，谢谢！！！这肯定是一个糟糕的方法，因为它只适用于输入值的一小部分它能成功产生的最大输出是输入值
0000001111111111
的
1023
任何大于该值的值都将产生
toBinaryString（1024）
的
1000000000
输出，这对于
parseInt（…）来说太大了
因此，如果格式化程序只有16个字符宽，那么输入仅适用于64K个可能输入值中的1K个？为什么不
%32s
？
numB
和
num
是相等的，没有任何不同
Integer.toBinaryString( (1 << len) | (val & ((1 << len) - 1)) ).substring( 1 )

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

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

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

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

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

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