如何在java中獲得整數的0填充二進制表示？

Question

例如，對於1, 2, 128, 256輸出可以是（16 位）：

0000000000000001
0000000000000010
0000000010000000
0000000100000000

我試過

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

它為左填充放置了空間：

`               1'

如何將0 s 用於填充。 我在Formatter 中找不到它。 還有另一種方法嗎？

PS 這篇文章描述了如何用左 0 填充來格式化整數，但它不是用於二進制表示。

Answer 1

我認為這是一個次優的解決方案，但你可以這樣做

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

Answer 2

java.util.Formatter 中沒有內置二進制轉換，我建議您使用 String.replace 用零替換空格字符，如下所示：

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

或者實現你自己的邏輯來將整數與沿指定的行加左填充的地方二進制表示該如此。 或者，如果您確實需要將數字傳遞給格式，則可以將二進制表示形式轉換為 BigInteger，然后使用前導零對其進行格式化，但這在運行時非常昂貴，例如：

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

Answer 3

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

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

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

Answer 5

我嘗試了各種我以前從未真正使用過的方法調用來完成這項工作，它們取得了一定的成功，直到我想到了一些非常簡單的東西，它可能會起作用，並且確實如此！

我確定之前已經考慮過它，不確定它對長串二進制代碼是否有好處，但它適用於 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;

Answer 6

user3608934 想法的更簡單版本“這是一個老技巧，創建一個包含 16 個 0 的字符串，然后附加您得到的修剪后的二進制字符串”：

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

Answer 7

我不知道“正確”的解決方案，但我可以建議你一個快速補丁。

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

我剛剛嘗試過，發現它工作正常。

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

Answer 9

嘗試...

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

我不認為這是這樣做的“正確”方式......但它有效:)

Answer 10

一個可行的天真解決方案是

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

Answer 11

這是一個老技巧，創建一個包含 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 );
    }
}

Answer 12

我會用下面的方法編寫我自己的 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 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();
}

Answer 14

您可以使用 lib https://github.com/kssource/BitSequence 。 它接受一個數字並返回 bynary 字符串，填充和/或分組。

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 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)。 通過使用繼續。

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

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

Answer 18

String binaryString = Integer.toBinaryString(2);
while (binaryString.length() < 32) binaryString = "0" + binaryString;

由於Java的整數始終為32位，因此您可以在二進制字符串前加零，直到其長度為32個字符（即32個二進制數字）為止。