Bagaimana cara mendapatkan representasi biner 0-padded dari sebuah integer di java?

misalnya untuk 1, 2, 128, 256outputnya bisa (16 digit):

0000000000000001
0000000000000010
0000000010000000
0000000100000000

Saya mencoba

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

itu menempatkan spasi untuk bantalan kiri:

`               1'

Bagaimana menempatkan 0s untuk bantalan. Saya tidak bisa menemukannya di Formatter . Apakah ada cara lain untuk melakukannya?

PS posting ini menjelaskan bagaimana memformat bilangan bulat dengan kiri 0-padding, tetapi bukan untuk representasi biner.

Saya pikir ini adalah solusi suboptimal, tetapi Anda bisa melakukannya

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

Tidak ada konversi biner yang dibangun ke dalam java.util.Formatter, saya akan menyarankan Anda untuk menggunakan String.replace untuk mengganti karakter spasi dengan nol, seperti di:

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

Atau terapkan logika Anda sendiri untuk mengonversi bilangan bulat menjadi representasi biner dengan menambahkan padding kiri di suatu tempat di sepanjang garis yang diberikan dalam hal ini . Atau jika Anda benar-benar perlu meneruskan angka ke format, Anda dapat mengonversi representasi biner Anda ke BigInteger dan kemudian memformatnya dengan nol di depan, tetapi ini sangat mahal pada waktu proses, seperti di:

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

Anda dapat menggunakan Apache Commons StringUtils . Ini menawarkan metode untuk padding string:

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

Saya mencoba semua jenis pemanggilan metode yang belum pernah saya gunakan sebelumnya untuk membuat ini berhasil, mereka bekerja dengan kesuksesan sedang, sampai saya memikirkan sesuatu yang sangat sederhana sehingga mungkin berhasil, dan berhasil!

Saya yakin itu telah dipikirkan sebelumnya, tidak yakin apakah itu bagus untuk string kode biner yang panjang tetapi berfungsi dengan baik untuk string 16Bit. Semoga membantu !! (Perhatikan bagian kode kedua ditingkatkan)

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

Terima kasih kepada Will yang telah membantu meningkatkan jawaban ini agar berhasil tanpa satu putaran. Ini mungkin sedikit kikuk tetapi berhasil, harap tingkatkan dan beri komentar kembali jika Anda bisa ....

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;

Berikut jawaban baru untuk posting lama.

Untuk memasukkan nilai biner dengan angka nol di depan ke panjang tertentu, coba ini:

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

Jika len = 4dan val = 1,

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

mengembalikan string "10001", lalu

"10001".substring( 1 )

membuang karakter pertama. Jadi kami mendapatkan apa yang kami inginkan:

"0001"

Jika valcenderung negatif, coba:

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

Versi sederhana dari ide user3608934 "Ini adalah trik lama, buat string dengan 16 0 lalu tambahkan string biner terpangkas yang Anda dapatkan":

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

Saya tidak tahu solusi yang "tepat" tetapi saya dapat menyarankan Anda untuk melakukan patch cepat.

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

Saya baru saja mencobanya dan ternyata berfungsi dengan baik.

mencoba...

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

Saya rasa ini bukan cara yang "benar" untuk melakukan ini ... tetapi berhasil :)

Solusi naif yang akan berhasil

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

Salah satu metode lainnya adalah

String temp = Integer.toBinaryString((m | 0x80000000));
temp = temp.substring(Integer.SIZE - Short.SIZE);

Ini akan menghasilkan string 16 bit dari integer 5

Dimulai dengan Java 11, Anda dapat menggunakan metode repeat (...) :

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

Atau, jika Anda memerlukan representasi 32-bit dari bilangan bulat apa pun:

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

Ini adalah trik lama, buat string dengan 16 0 lalu tambahkan string biner terpangkas yang Anda dapatkan dari String.format ("% s", Integer.toBinaryString (1)) dan gunakan 16 karakter paling kanan, potong semua karakter utama 0. Lebih baik lagi, buat fungsi yang memungkinkan Anda menentukan berapa panjang string biner yang Anda inginkan. Tentu saja mungkin ada banyak cara lain untuk melakukannya termasuk perpustakaan, tetapi saya menambahkan posting ini untuk membantu teman :)

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

Saya akan menulis kelas util saya sendiri dengan metode seperti di bawah ini

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

}

Keluaran:

5
101
0000000000000000000000000000000000000000000000000000000000000101

Pendekatan yang sama dapat diterapkan pada semua tipe integral. Perhatikan jenis topengnya

long mask = 1L << i;

Metode ini mengubah int menjadi String, length = bits. Entah diisi dengan 0 atau dengan bit paling signifikan terpotong.

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

Anda dapat menggunakan lib https://github.com/kssource/BitSequence . Ini menerima nomor dan mengembalikan string bynary, empuk dan / atau dikelompokkan.

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()adalah panjang angka katakanlah 2 dalam biner adalah 01 yaitu panjang 2 ubah 4 menjadi panjang maksimal angka yang diinginkan. Ini dapat dioptimalkan ke O (n). dengan menggunakan lanjutkan.

// Di bawah ini akan menangani ukuran yang sesuai

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