Cara mengonversi byte ke representasi string binernya

95

Misalnya, bit dalam byte Badalah 10000010, bagaimana saya dapat menetapkan bit ke string strsecara harfiah, yaitu , str = "10000010".

Edit

Saya membaca byte dari file biner, dan disimpan dalam array byte B. Saya menggunakan System.out.println(Integer.toBinaryString(B[i])). masalahnya adalah

(a) ketika bit dimulai dengan (paling kiri) 1, outputnya tidak benar karena diubah B[i]menjadi nilai int negatif.

(b) jika bit dimulai dengan 0, keluaran akan diabaikan 0, misalnya, anggap B[0]memiliki 00000001, keluarannya adalah 1sebagai pengganti00000001

Sean
sumber
2
Saya bingung; apakah ini tipuan?
Dave Newton
1
Apakah Anda bertanya bagaimana mengubah a bytemenjadi string di basis 2?
SLaks
Aku hanya menambahkan jawaban untuk thread lain untuk melakukan hal ini (mengkonversi nilai ke suatu String digit biner) yang bekerja untuk Boolean, Byte, Short, Char, Int, dan Long. stackoverflow.com/a/54950845/501113
chaotic3quilibrium
String # Format () mungkin bisa menangani ini, jika Anda menyuruhnya menggunakan lebar 8. Demikian juga System.out.printf ().
NomadMaker

Jawaban:

173

Penggunaan Integer#toBinaryString():

byte b1 = (byte) 129;
String s1 = String.format("%8s", Integer.toBinaryString(b1 & 0xFF)).replace(' ', '0');
System.out.println(s1); // 10000001

byte b2 = (byte) 2;
String s2 = String.format("%8s", Integer.toBinaryString(b2 & 0xFF)).replace(' ', '0');
System.out.println(s2); // 00000010

DEMO .

João Silva
sumber
Saya mencoba metode ini. Dalam kasus saya, saya membaca byte dari file biner, dan disimpan dalam array byte B. Saya menggunakan System.out.println(Integer.toBinaryString(B[i])). Ketika saya menggunakan metode ini, masalahnya adalah (a) ketika bit dimulai dengan (paling kiri) 1, outputnya tidak benar karena diubah B[i]ke nilai int negatif. (b) jika bit dimulai dengan 0, output mengabaikan 0, misalnya, menganggap B[0]memiliki 00000001, output adalah 1bukan00000001
Sean
1
@ Sean: a) terjadi karena a bytedi Java adalah bilangan bulat pelengkap dua bertanda tangan 8-bit. Nilai minimumnya adalah -128 (2 ^ 8), dan nilai maksimumnya adalah 127; b) Anda dapat dengan mudah memperbaikinya dengan menggunakan ini String.format("%8s", Integer.toBinaryString(b)).replace(' ', '0')ke pad kiri string yang dihasilkan dengan nol.
João Silva
1
@ João: terima kasih atas saran Anda. Apakah Anda tahu cara mengalamatkan (a), cara menyimpan format bit asli (dimulai dengan 1) ke dalam string?
Sean
1
@ Sean: Ya, hanya &dengan 0xFF.
João Silva
14
@ Sean: & 0xFFpada dasarnya mengubah a signed bytemenjadi unsigned integer. Misalnya, -129seperti yang Anda katakan, diwakili oleh 11111111111111111111111110000001. Dalam hal ini, Anda pada dasarnya menginginkan 8 bit pertama (paling tidak signifikan), jadi Anda DAN ( &) dengan 0xFF( 00000000000000000000000011111111), secara efektif membersihkan 1 ke kiri yang tidak kita pedulikan, biarkan saja 10000001.
João Silva
37

Saya menggunakan ini. Ide yang mirip dengan jawaban lain, tetapi tidak melihat pendekatan yang tepat di mana pun :)

System.out.println(Integer.toBinaryString((b & 0xFF) + 0x100).substring(1));

0xFFadalah 255, atau 11111111(nilai maks untuk byte yang tidak bertanda tangan). 0x100adalah 256, atau100000000

The &upcasts byte ke integer. Pada titik itu, bisa apa saja dari 0- 255( 00000000hingga 11111111, saya mengecualikan 24 bit terkemuka). + 0x100dan .substring(1)memastikan akan ada angka nol di depan.

Saya menghitung waktunya dibandingkan dengan jawaban João Silva , dan ini 10 kali lebih cepat. http://ideone.com/22DDK1 Saya tidak menyertakan jawaban Pshemo karena tidak sesuai dengan benar.

Raekye
sumber
Hei! mendapat pertanyaan tentang ini. Saya memiliki string representasi Base64 dari PDF, saya perlu mengubahnya menjadi Biner. Pada dasarnya, Base64-> byte-> binary. Akankah kode ini berfungsi?
Sid
Apa tepatnya yang dilakukan + 0x100? Anda menambahkan 256 ke bilangan bulat yang dihasilkan, tetapi mengapa?
Conner Dassen
1
@ConnerDassen Ini memastikan bahwa string biner adalah 0 empuk. Misalnya, jika bada 1, tanpa + 0x100Anda hanya akan mendapatkan "1"sebagai string Anda. Dengan menambahkan 1, Anda mendapatkan 100000001, dan jika Anda mengambil substring dengan mengabaikan karakter pertama, Anda akan mendapatkan hak "00000001". Jika Anda tidak ingin senar Anda menjadi empuk, Anda dapat menggunakan Integer.toBinaryString(b & 0xff). The & 0xffperbaikan negatif / dua ini isu pelengkap
Raekye
8

Apa ini yang kamu cari?

mengkonversi dari String ke byte

byte b = (byte)(int)Integer.valueOf("10000010", 2);
System.out.println(b);// output -> -126

mengkonversi dari byte ke String

System.out.println(Integer.toBinaryString((b+256)%256));// output -> "10000010"

Atau seperti yang João Silva katakan dalam komentarnya untuk menambahkan leading 0kita dapat memformat string menjadi panjang 8 dan mengganti spasi terdepan yang dihasilkan dengan nol, jadi dalam kasus string seperti " 1010"kita akan mendapatkan"00001010"

System.out.println(String.format("%8s", Integer.toBinaryString((b + 256) % 256))
                         .replace(' ', '0'));
Pshemo
sumber
6

Anda dapat memeriksa setiap bit pada byte lalu menambahkan 0 atau 1 ke string. Berikut adalah metode pembantu kecil yang saya tulis untuk pengujian:

public static String byteToString(byte b) {
    byte[] masks = { -128, 64, 32, 16, 8, 4, 2, 1 };
    StringBuilder builder = new StringBuilder();
    for (byte m : masks) {
        if ((b & m) == m) {
            builder.append('1');
        } else {
            builder.append('0');
        }
    }
    return builder.toString();
}
Martyn
sumber
3

Dapatkan setiap bit byte dan ubah menjadi string. Katakanlah byte memiliki 8 bit, dan kita bisa mendapatkannya satu per satu melalui bit move. Sebagai contoh, kita memindahkan bit kedua dari bit 6 bit ke kanan, bit kedua terakhir bit 8 bit, kemudian (&) dengan 0x0001 untuk membersihkan bit depan.

public static String getByteBinaryString(byte b) {
    StringBuilder sb = new StringBuilder();
    for (int i = 7; i >= 0; --i) {
        sb.append(b >>> i & 1);
    }
    return sb.toString();
}
jamee
sumber
Bisakah Anda mengedit jawaban Anda untuk memberikan penjelasan mengapa kode ini menjawab pertanyaan? Jawaban kode saja tidak disarankan , karena tidak mengajarkan solusinya.
DavidPostill
2

Kode ini akan mendemonstrasikan bagaimana java int dapat dibagi menjadi 4 byte berturut-turut. Kami kemudian dapat memeriksa setiap byte menggunakan metode Java dibandingkan dengan interogasi byte / bit tingkat rendah.

Ini adalah keluaran yang diharapkan ketika Anda menjalankan kode di bawah ini:

[Input] Integer value: 8549658

Integer.toBinaryString: 100000100111010100011010
Integer.toHexString: 82751a
Integer.bitCount: 10

Byte 4th Hex Str: 0
Byte 3rd Hex Str: 820000
Byte 2nd Hex Str: 7500
Byte 1st Hex Str: 1a

(1st + 2nd + 3rd + 4th (int(s)) as Integer.toHexString: 82751a
(1st + 2nd + 3rd + 4th (int(s)) ==  Integer.toHexString): true

Individual bits for each byte in a 4 byte int:
00000000 10000010 01110101 00011010

Berikut kode untuk dijalankan:

public class BitsSetCount
{
    public static void main(String[] args) 
    {
        int send = 8549658;

        System.out.println( "[Input] Integer value: " + send + "\n" );
        BitsSetCount.countBits(  send );
    }

    private static void countBits(int i) 
    {
        System.out.println( "Integer.toBinaryString: " + Integer.toBinaryString(i) );
        System.out.println( "Integer.toHexString: " + Integer.toHexString(i) );
        System.out.println( "Integer.bitCount: "+ Integer.bitCount(i) );

        int d = i & 0xff000000;
        int c = i & 0xff0000;
        int b = i & 0xff00;
        int a = i & 0xff;

        System.out.println( "\nByte 4th Hex Str: " + Integer.toHexString(d) );
        System.out.println( "Byte 3rd Hex Str: " + Integer.toHexString(c) );
        System.out.println( "Byte 2nd Hex Str: " + Integer.toHexString(b) );
        System.out.println( "Byte 1st Hex Str: " + Integer.toHexString(a) );

        int all = a+b+c+d;
        System.out.println( "\n(1st + 2nd + 3rd + 4th (int(s)) as Integer.toHexString: " + Integer.toHexString(all) );

        System.out.println("(1st + 2nd + 3rd + 4th (int(s)) ==  Integer.toHexString): " + 
                Integer.toHexString(all).equals(Integer.toHexString(i) ) );

        System.out.println( "\nIndividual bits for each byte in a 4 byte int:");

        /*
         * Because we are sending the MSF bytes to a method
         * which will work on a single byte and print some
         * bits we are generalising the MSF bytes
         * by making them all the same in terms of their position
         * purely for the purpose of printing or analysis
         */
        System.out.print( 
                    getBits( (byte) (d >> 24) ) + " " + 
                    getBits( (byte) (c >> 16) ) + " " + 
                    getBits( (byte) (b >> 8) ) + " " + 
                    getBits( (byte) (a >> 0) ) 
        );


    }

    private static String getBits( byte inByte )
    {
        // Go through each bit with a mask
        StringBuilder builder = new StringBuilder();
        for ( int j = 0; j < 8; j++ )
        {
            // Shift each bit by 1 starting at zero shift
            byte tmp =  (byte) ( inByte >> j );

            // Check byte with mask 00000001 for LSB
            int expect1 = tmp & 0x01; 

            builder.append(expect1);
        }
        return ( builder.reverse().toString() );
    }

}
Naresh Maharaj
sumber
2
Integer.toBinaryString((byteValue & 0xFF) + 256).substring(1)
Timofey Gorshkov
sumber
2

Maaf saya tahu ini agak terlambat ... Tapi saya punya cara yang jauh lebih mudah ... Untuk string biner:

//Add 128 to get a value from 0 - 255
String bs = Integer.toBinaryString(data[i]+128);
bs = getCorrectBits(bs, 8);

Metode getCorrectBits:

private static String getCorrectBits(String bitStr, int max){
    //Create a temp string to add all the zeros
    StringBuilder sb = new StringBuilder();
    for(int i = 0; i < (max - bitStr.length()); i ++){
        sb.append("0");
    }

    return sb.toString()+ bitStr;
}
Jp Silver
sumber
1
String byteToBinaryString(byte b){
    StringBuilder binaryStringBuilder = new StringBuilder();
    for(int i = 0; i < 8; i++)
        binaryStringBuilder.append(((0x80 >>> i) & b) == 0? '0':'1');
    return binaryStringBuilder.toString();
}
Shahidul
sumber
1

Anda dapat bekerja dengan BigInteger seperti contoh di bawah ini, terutama jika Anda memiliki 256 bit atau lebih lama:

String string = "10000010";
BigInteger biStr = new BigInteger(string, 2);

System.out.println("binary: " + biStr.toString(2));
System.out.println("hex: " + biStr.toString(16));
System.out.println("dec: " + biStr.toString(10));

Contoh lain yang menerima byte:

String string = "The girl on the red dress.";

byte[] byteString = string.getBytes(Charset.forName("UTF-8"));
System.out.println("[Input String]: " + string);
System.out.println("[Encoded String UTF-8]: " + byteString);

BigInteger biStr = new BigInteger(byteString);
System.out.println("binary: " + biStr.toString(2)); // binary
System.out.println("hex: " + biStr.toString(16));   // hex or base 16
System.out.println("dec: " + biStr.toString(10));  // this is base 10

Hasil:

[Input String]: The girl on the red dress.
[Encoded String UTF-8]: [B@70dea4e

binary: 101010001101000011001010010000001100111011010010111001001101100001000000110111101101110001000000111010001101000011001010010000001110010011001010110010000100000011001000111001001100101011100110111001100101110
hex: 546865206769726c206f6e20746865207265642064726573732e

Anda juga dapat bekerja untuk mengonversi format Biner ke Byte

try {
   System.out.println("binary to byte: " + biStr.toString(2).getBytes("UTF-8"));
} catch (UnsupportedEncodingException e) {e.printStackTrace();}

Catatan: Untuk pemformatan string untuk format Biner Anda, Anda dapat menggunakan contoh di bawah ini

String.format("%256s", biStr.toString(2).replace(' ', '0'));  // this is for the 256 bit formatting
Josef Panerio
sumber
1

Jawaban sederhana bisa jadi:

System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})); // 0
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1})); // 1
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0})); // 256
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0})); // 65536
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0})); // 16777216
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0})); // 4294967296
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0})); // 1099511627776
System.out.println(new BigInteger(new byte[]{0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0})); // 281474976710656
System.out.println(new BigInteger(new byte[]{0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0})); // 72057594037927936
System.out.println(new BigInteger(new byte[]{0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0})); // 18446744073709551616
System.out.println(new BigInteger(new byte[]{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0})); // 4722366482869645213696
System.out.println(new BigInteger(new byte[]{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})); // 1208925819614629174706176
System.out.println(Long.MAX_VALUE);                                              // 9223372036854775807
Daniel De León
sumber
0

Kita semua tahu bahwa Java tidak menyediakan kata kunci unsigned. Selain itu, byteprimitif menurut spesifikasi Java mewakili nilai antara −128dan 127. Misalnya, jika a byteadalah castuntuk intJava akan menafsirkan yang pertama bitsebagai signdan menggunakan ekstensi tanda.

Lalu, bagaimana mengkonversi byte yang lebih besar dari 127representasi string binernya ??

Tidak ada yang menghalangi Anda untuk melihat bytehanya sebagai 8-bit dan menafsirkan bit-bit tersebut sebagai nilai antara 0dan 255. Selain itu, Anda perlu mengingat bahwa tidak ada yang dapat Anda lakukan untuk memaksakan interpretasi Anda pada metode orang lain. Jika suatu metode menerima a byte, maka metode itu menerima nilai antara −128dan 127kecuali secara eksplisit dinyatakan lain.

Jadi cara terbaik untuk menyelesaikannya adalah mengubah bytenilai menjadi intnilai dengan memanggil Byte.toUnsignedInt()metode atau mentransmisikannya sebagai intprimitif (int) signedByte & 0xFF. Di sini Anda memiliki contoh:

public class BinaryOperations
{
    public static void main(String[] args)
    {
        byte forbiddenZeroBit = (byte) 0x80;

        buffer[0] = (byte) (forbiddenZeroBit & 0xFF);
        buffer[1] = (byte) ((forbiddenZeroBit | (49 << 1)) & 0xFF);
        buffer[2] = (byte) 96;
        buffer[3] = (byte) 234;

        System.out.println("8-bit header:");
        printBynary(buffer);
    }

    public static void printBuffer(byte[] buffer)
    {
        for (byte num : buffer) {
            printBynary(num);
        }
    }

    public static void printBynary(byte num)
    {
        int aux = Byte.toUnsignedInt(num);
        // int aux = (int) num & 0xFF; 
        String binary = String.format("%8s', Integer.toBinaryString(aux)).replace(' ', '0');
        System.out.println(binary);
    }
}

Keluaran

8-bit header:
10000000
11100010
01100000
11101010
Teocci
sumber
0

Hanya petunjuk lain bagi mereka yang perlu mengonversi byte secara besar-besaran menjadi string biner: Gunakan tabel pencarian daripada menggunakan operasi String tersebut sepanjang waktu. Ini jauh lebih cepat daripada memanggil fungsi convert berulang kali

public class ByteConverterUtil {

  private static final String[] LOOKUP_TABLE = IntStream.range(0, Byte.MAX_VALUE - Byte.MIN_VALUE + 1)
                                                        .mapToObj(intValue -> Integer.toBinaryString(intValue + 0x100).substring(1))
                                                        .toArray(String[]::new);

  public static String convertByte(final byte byteValue) {
    return LOOKUP_TABLE[Byte.toUnsignedInt(byteValue)];
  }

  public static void main(String[] args){
    System.out.println(convertByte((byte)0)); //00000000
    System.out.println(convertByte((byte)2)); //00000010
    System.out.println(convertByte((byte)129)); //10000001
    System.out.println(convertByte((byte)255)); //11111111
  }


}
rloeffel.dll
sumber
-1

Hanya menebak-nebak di sini, tetapi jika Anda memiliki Byte maka tidak bisakah Anda memanggil toString () pada objek untuk mendapatkan nilainya? Atau, melihat sekilas api , menggunakan byteValue ()?

geogaddi
sumber