如何在java中获得整数的0填充二进制表示？
Posted
技术标签:
【中文标题】如何在java中获得整数的0填充二进制表示？【英文标题】：How to get 0-padded binary representation of an integer in java? 【发布时间】：2011-05-24 05:05:48 【问题描述】：例如，对于1, 2, 128, 256，输出可以是（16 位）：
0000000000000001
0000000000000010
0000000010000000
0000000100000000
我试过了
String.format("%16s", Integer.toBinaryString(1));
它为左填充放置空格：
` 1'
如何将0s 用于填充。我在Formatter 中找不到它。还有其他方法吗？
附： this post 描述了如何使用左 0 填充格式化整数，但它不适用于二进制表示。
【问题讨论】：
您是否尝试过使用%016s？
@Deniz 是的，它失败了 Exception in thread "main" java.util.FormatFlagsConversionMismatchException: Conversion = s, Flags = 0
看看这个：***.com/a/15124135/1316649
【参考方案1】：
我认为这是一个次优的解决方案，但你可以这样做
String.format("%16s", Integer.toBinaryString(1)).replace(' ', '0')
【讨论】：
是的，我现在就这样做，但我相信应该有其他方法 :) 谢谢。 其实在做了一些研究之后，看起来你不能仅仅使用 printf 语法。所以也许它毕竟不是那么糟糕。 @Daniel 负数不会包含任何空格，所以也可以。 @Daniel Integer::toBinaryString 文档：Returns a string representation of the integer argument as an unsigned integer in base 2.【参考方案2】：
java.util.Formatter 中没有内置二进制转换，我建议您使用 String.replace 将空格字符替换为零，如下所示：
String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0")
或者实现您自己的逻辑，将整数转换为二进制表示，并在this 中给出的行中添加左填充。 或者，如果您确实需要将数字传递给格式，则可以将二进制表示形式转换为 BigInteger，然后使用前导零对其进行格式化，但这在运行时非常昂贵，如下所示：
String.format("%016d", new BigInteger(Integer.toBinaryString(1)))
【讨论】：
谢谢，这个更好，因为它避免了大数字的溢出（例如 2^30）。 是的，但我真的不会这样做，我会使用替换方法或我自己的填充方法：一种方法是再次使用 String.format 来格式化所需的填充长度，参数为零，或在代码中： String.format("%0" + (32 - binary.length()) + "d"%s", 0, binary) 当然你需要注意 32 - binary 的负面结果。长度（）...【参考方案3】：您可以使用 Apache Commons StringUtils。它提供了填充字符串的方法：
StringUtils.leftPad(Integer.toBinaryString(1), 16, '0');
【讨论】：
【参考方案4】：这是旧帖子的新答案。
要将带有前导零的二进制值填充到特定长度，请尝试以下操作：
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 )
【讨论】：
简洁优雅。【参考方案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;
【讨论】：
这是一个不错且简单的解决方案。可以通过使用binString.length() 和 16 之间的差异来创建一个字符串，然后将该字符串附加到 binString 而不是循环使用类似这样的答案来改进它：***.com/a/2804866/1353098
威尔 - 你太棒了，我现在就把它放到我的代码中！我也不喜欢循环，谢谢！！！【参考方案6】：
user3608934 想法的更简单版本“这是一个老把戏，创建一个包含 16 个 0 的字符串，然后附加你得到的修剪后的二进制字符串”：
private String toBinaryString32(int i)
String binaryWithOutLeading0 = Integer.toBinaryString(i);
return "00000000000000000000000000000000"
.substring(binaryWithOutLeading0.length())
+ binaryWithOutLeading0;
【讨论】：
【参考方案7】：我不知道“正确”的解决方案，但我可以建议你一个快速的补丁。
String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0");
我刚刚试了一下，效果很好。
【讨论】：
为什么格式化程序只有 16 个字符宽？为什么不%32s？【参考方案8】：
从 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 位版本，不应该像 32 位版本一样检查i 是否为零吗？【参考方案9】：
试试……
String.format("%016d\n", Integer.parseInt(Integer.toBinaryString(256)));
我不认为这是执行此操作的“正确”方法...但它有效:)
【讨论】：
这当然是一个糟糕的方法，因为它只适用于输入值的一小部分......它可以成功产生的最大输出是0000001111111111 输入值@987654323 @ 任何大于该值的值都将产生来自10000000000 的toBinaryString(1024) 的输出，这对于parseInt(...) 来说太大了因此，输入仅适用于64K 可能的输入值中的1K【参考方案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 000000000000000000000000000000000000000000000000000000000000000101同样的方法可以应用于任何整数类型。注意口罩的种类
long mask = 1L << i;
【讨论】：
【参考方案11】：一个可行的简单解决方案是
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 的 16 位字符串
【讨论】：
【参考方案12】：这是一个老技巧，创建一个包含 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 );
【讨论】：
【参考方案13】：此方法将 int 转换为 String，length=bits。用 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();
【讨论】：
【参考方案14】：您可以使用 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
【讨论】：
【参考方案15】：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)。
通过使用继续。
【讨论】：
【参考方案16】：// 下面将处理适当的尺寸
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');
【讨论】：
【参考方案17】：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");
【讨论】：
numB 和 num 相等且没有任何不同以上是关于如何在java中获得整数的0填充二进制表示？的主要内容，如果未能解决你的问题，请参考以下文章