So konvertieren Sie ein Byte in seine binäre Zeichenfolgendarstellung

Die Bits in einem Byte Bsind beispielsweise 10000010: Wie kann ich die Bits der Zeichenfolge strbuchstäblich zuweisen , d str = "10000010". H.

Bearbeiten

Ich habe das Byte aus einer Binärdatei gelesen und im Byte-Array gespeichert B. Ich benutze System.out.println(Integer.toBinaryString(B[i])). das Problem ist

(a) Wenn die Bits mit (ganz links) 1 beginnen, ist die Ausgabe nicht korrekt, da sie B[i]in einen negativen int-Wert konvertiert wird.

(b) Wenn die Bits mit beginnen 0, ignoriert die Ausgabe 0beispielsweise B[0]00000001, die Ausgabe ist 1anstelle von00000001

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

Ich habe das benutzt. Ähnliche Idee wie bei anderen Antworten, aber nirgendwo genau gesehen :)

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

0xFFist 255 oder 11111111(Maximalwert für ein vorzeichenloses Byte). 0x100ist 256 oder100000000

Das &überträgt das Byte auf eine Ganzzahl. An diesem Punkt kann es alles sein von 0- 255( 00000000bis 11111111, ich habe die führenden 24 Bits ausgeschlossen). + 0x100und stellen Sie .substring(1)sicher, dass es führende Nullen gibt.

Ich habe es im Vergleich zu João Silvas Antwort zeitlich festgelegt , und das ist mehr als zehnmal schneller. http://ideone.com/22DDK1 Ich habe Pshemos Antwort nicht aufgenommen, da sie nicht richtig aufgefüllt ist.

Suchst du danach?

Konvertieren von String in Byte

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

Konvertieren von Byte in String

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

Oder wie João Silva in seinem Kommentar zum Hinzufügen von führenden Zeichen sagte, 0können wir die Zeichenfolge auf Länge 8 formatieren und die resultierenden führenden Leerzeichen durch Null ersetzen, also im Falle einer Zeichenfolge, wie " 1010"wir sie erhalten"00001010"

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

Sie können jedes Bit im Byte überprüfen und dann entweder 0 oder 1 an eine Zeichenfolge anhängen. Hier ist eine kleine Hilfsmethode, die ich zum Testen geschrieben habe:

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

Holen Sie sich jedes Bit Byte und konvertieren Sie es in einen String. Angenommen, Byte hat 8 Bits, und wir können sie einzeln durch Bitverschiebung erhalten. Zum Beispiel verschieben wir das zweite Bit des Bytes um 6 Bits nach rechts, das zweite Bit zuletzt um das Bit mit 8 Bits und dann (&) mit 0x0001, um die vorderen Bits zu reinigen.

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

Dieser Code zeigt, wie ein Java-Int in seine 4 aufeinander folgenden Bytes aufgeteilt werden kann. Wir können dann jedes Byte mit Java-Methoden im Vergleich zur Abfrage von Bytes / Bits auf niedriger Ebene untersuchen.

Dies ist die erwartete Ausgabe, wenn Sie den folgenden Code ausführen:

[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

Hier ist der auszuführende Code:

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

}

Integer.toBinaryString((byteValue & 0xFF) + 256).substring(1)

Tut mir leid, dass ich weiß, dass dies etwas spät ist ... Aber ich habe einen viel einfacheren Weg ... Zur binären Zeichenfolge:

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

getCorrectBits-Methode:

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

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

Wir alle wissen, dass Java so etwas wie das nicht signierte Schlüsselwort nicht bereitstellt. Darüber hinaus byterepräsentiert ein Grundelement gemäß der Java-Spezifikation einen Wert zwischen −128und 127. Zum Beispiel, wenn eine byteist castmit einem intJava wird die erste interpretieren bitals die signund die Verwendung Vorzeichenerweiterung.

Wie konvertiere ich dann ein Byte, das größer ist als 127in seine binäre Zeichenfolgendarstellung?

Nichts hindert Sie daran, ein byteeinfaches 8-Bit anzuzeigen und diese Bits als Wert zwischen 0und zu interpretieren 255. Außerdem müssen Sie bedenken, dass Sie nichts tun können, um Ihre Interpretation der Methode eines anderen aufzuzwingen. Wenn eine Methode a akzeptiert byte, akzeptiert diese Methode einen Wert zwischen −128und127 sofern nicht ausdrücklich anders angegeben.

Der beste Weg, dies zu lösen, besteht darin, den byteWert in einen intWert umzuwandeln, indem Sie die Byte.toUnsignedInt()Methode aufrufen oder als intGrundelement umwandeln (int) signedByte & 0xFF. Hier haben Sie ein Beispiel:

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

Ausgabe

8-bit header:
10000000
11100010
01100000
11101010

Sie können mit BigInteger wie im folgenden Beispiel arbeiten, insbesondere wenn Sie 256 Bit oder länger haben:

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

Ein weiteres Beispiel, das Bytes akzeptiert:

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

Ergebnis:

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

binary: 101010001101000011001010010000001100111011010010111001001101100001000000110111101101110001000000111010001101000011001010010000001110010011001010110010000100000011001000111001001100101011100110111001100101110
hex: 546865206769726c206f6e20746865207265642064726573732e

Sie können auch daran arbeiten, das Binärformat in das Byte- Format zu konvertieren

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

Hinweis: Für die Formatierung von Zeichenfolgen für Ihr Binärformat können Sie das folgende Beispiel verwenden

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

Ich rate hier nur, aber wenn Sie ein Byte haben, können Sie dann nicht einfach toString () für das Objekt aufrufen, um den Wert zu erhalten? Oder mit byteValue () auf die API blicken?