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

小开

最佳答案

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

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

小开

试试..。

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

我不认为这是做这件事的“正确”方法... ... 但它确实有效:)

小开

Java.util 中没有内置任何二进制转换。Formatter，我建议您使用 String.place 将空格字符替换为零，如下所示:

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

或者实现您自己的逻辑，将整数转换为二进制表示，并在这个中给出的行的某处添加左边填充，以便。或者，如果你真的需要传递数字来格式化，你可以把你的二进制表示转换成 BigInteger，然后用前导零来格式化，但是这在运行时代价很高，比如:

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

小开

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

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

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

小开

我尝试了各种各样的方法调用，我以前没有真正使用这个工作，他们工作的中等成功，直到我想到的东西是如此简单，它可能工作，而且它做到了！

我相信以前也有人这么想过，不确定它对于长串的二进制代码是否有用，但是对于16位字符串却很好用。希望能有帮助！(注意，第二段代码得到了改进)

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

感谢威尔帮助改进这个答案，使其工作没有一个循环。这可能有点笨拙，但它的工作，请提高和评论回来，如果你可以... 。

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;

小开

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

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

小开

这是一个老把戏，创建一个字符串与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 );
}
}

小开

一个更简单的 user3608934的想法“这是一个老把戏，创建一个160的字符串，然后添加修剪过的二进制字符串”:

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

小开

这是旧帖子的新答案。

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

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 )

小开

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

小开

此方法将 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();
}

小开

一个天真的解决方案

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位字符串

小开

您可以使用 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是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");
}
}
}

小开

从 Java11开始，您可以使用重复(...)方法:

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

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

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