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


120

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.


Sudahkah Anda mencoba menggunakan %016s?
Deniz Dogan

1
@Deniz ya, gagal denganException in thread "main" java.util.FormatFlagsConversionMismatchException: Conversion = s, Flags = 0
khachik

Jawaban:


198

Saya pikir ini adalah solusi suboptimal, tetapi Anda bisa melakukannya

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

1
Ya, saya melakukannya sekarang, tetapi saya yakin seharusnya ada cara lain :) Terima kasih.
khachik

sebenarnya setelah melakukan beberapa penelitian, sepertinya Anda tidak bisa melakukannya hanya dengan menggunakan sintaks printf .. Jadi mungkin itu tidak terlalu buruk.
Samuel Parsonage

@Daniel Nomor negatif tidak akan berisi spasi, jadi ini juga berfungsi.
Eric Wang

@Daniel Integer :: toBinaryString doc:Returns a string representation of the integer argument as an unsigned integer in baseĀ 2.
Alan

17

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

Terima kasih, yang ini lebih baik, karena menghindari melimpahnya angka-angka besar (mis. 2 ^ 30).
khachik

1
Ya, tetapi saya benar-benar tidak akan melakukannya, saya akan menggunakan metode replace atau metode padding saya sendiri: salah satu caranya adalah menggunakan String.format lagi untuk memformat panjang padding yang diperlukan dengan argumen nol, atau dalam kode: String.format ( "% 0" + (32 - binary.length ()) + "d"% s ", 0, binary) tentu saja Anda harus memperhatikan hasil negatif dari 32 - binary.length () ...
Zoran Regvart

12

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

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

9

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;

Ini adalah solusi yang bagus dan sederhana. Ini dapat ditingkatkan dengan menggunakan perbedaan antara binString.length()dan 16 untuk membuat string dan kemudian menambahkan string itu ke binString daripada mengulang meskipun dengan sesuatu seperti ini jawaban: stackoverflow.com/a/2804866/1353098
Akankah

1
Akan - Anda brilian, sakit memasukkan itu ke dalam kode saya sekarang! Aku juga tidak suka loopnya, terima kasih !!!
Tom Spencer

7

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 )

5

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

4

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.


mengapa formatter hanya selebar 16 karakter? mengapa tidak %32s?
pembawa cincin

3

mencoba...

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

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


1
Hal ini tentunya cara yang buruk untuk melakukannya karena hanya bekerja hingga sebagian kecil dari nilai input .... Output terbesar dapat berhasil menghasilkan adalah 0000001111111111untuk nilai masukan 1023Setiap nilai yang lebih besar dari itu akan menghasilkan output dari toBinaryString(1024)dari 10000000000yang terlalu besar untuk parseInt(...)Jadi, input hanya bekerja untuk 1K dari 64K kemungkinan nilai input
rolfl

1

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


1

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)

0

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

0

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;


0

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

0

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

0
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.


0

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

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

1
numBdan numsama dan tidak berbeda dengan cara apa pun
igorepst
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.