web-dev-qa-db-fra.com

Comment convertir un octet en sa représentation sous forme de chaîne binaire

Par exemple, les bits d'un octet B sont 10000010, comment puis-je affecter les bits à la chaîne str littéralement, c'est-à-dire str = "10000010".

Éditer

J'ai lu l'octet d'un fichier binaire et stocké dans le tableau d'octets B. J'utilise System.out.println(Integer.toBinaryString(B[i])). le problème est

(a) lorsque les bits commencent par (le plus à gauche) 1, la sortie n'est pas correcte car elle convertit B[i] en une valeur int négative.

(b) si les bits commencent par 0, la sortie ignore 0, par exemple, supposons que B[0] a 00000001, la sortie est 1 au lieu de 00000001

javabinarybyte
78
Sean

Utilisez 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

DÉMO.

153
João Silva

J'ai utilisé ça. Idée similaire à d'autres réponses, mais je n'ai pas vu l'approche exacte nulle part :)

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

0xFF vaut 255 ou 11111111 (valeur maximale pour un octet non signé). 0x100 vaut 256 ou 100000000

Le & transforme l'octet en un entier. À ce stade, il peut s'agir de 0-255 (00000000 à 11111111, j'ai exclu les 24 bits précédents). + 0x100 et .substring(1) s'assurent qu'il y aura des zéros en tête.

Je l'ai chronométré comparé à réponse de João Silva , et c'est 10 fois plus rapide. http://ideone.com/22DDK1 Je n'ai pas inclus la réponse de Pshemo car elle ne répond pas correctement.

27
Raekye

Est-ce ce que vous recherchez?

convertir de chaîne en octet

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

convertir d'octet en chaîne

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

Ou, comme João Silva l'a dit dans son commentaire en ajoutant 0 en majuscule, nous pouvons formater une chaîne de longueur 8 et remplacer les espaces en majuscules par zéro, ainsi, dans le cas d'une chaîne comme " 1010", nous aurons "00001010".

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

Vous pouvez vérifier chaque bit de l'octet puis ajouter 0 ou 1 à une chaîne. Voici une petite méthode d'assistance que j'ai écrite pour les tests:

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

Ce code montrera comment un Java int peut être divisé en 4 octets consécutifs. Nous pouvons ensuite inspecter chaque octet en utilisant les méthodes Java par rapport à une interrogation de bas niveau octet/bit.

Voici le résultat attendu lorsque vous exécutez le code ci-dessous:

[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

Voici le code à exécuter:

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

}
2
Naresh Maharaj

Récupère chaque octet et convertit en chaîne. Supposons que l'octet a 8 bits et que nous pouvons les obtenir un par un via bit move. Par exemple, nous déplaçons le second bit de l'octet 6 bits vers la droite, le second bit enfin de 8 bits, puis et (&) avec 0x0001 pour nettoyer les bits frontaux.

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();
}
2
jamee
Integer.toBinaryString((byteValue & 0xFF) + 256).substring(1)
2
Timofey Gorshkov

Désolé je sais que c'est un peu tard ... Mais j'ai un moyen beaucoup plus simple ... Pour la chaîne binaire:

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

méthode getCorrectBits:

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

    return tmpStr + bitStr;
}
2
Jp Silver
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();
}
1
Shahidul

Nous savons tous que Java ne fournit rien de tel que le mot clé unsigned. De plus, une primitive byte selon les spécifications de Java représente une valeur comprise entre −128 et 127. Par exemple, si un byte est cast sur un int Java, le premier bit sera interprété comme le sign et utilisera l'extension de signe .

Ensuite, comment convertir un octet supérieur à 127 en sa représentation sous forme de chaîne binaire?

Rien ne vous empêche de visualiser un byte simplement en tant que 8 bits et d'interpréter ces bits comme une valeur comprise entre 0 et 255. En outre, vous devez garder à l'esprit qu'il n'y a rien que vous puissiez faire pour imposer votre interprétation à la méthode de quelqu'un d'autre. Si une méthode accepte un byte, cette méthode accepte une valeur comprise entre −128 et 127, sauf indication contraire explicite.

La meilleure façon de résoudre ce problème consiste donc à convertir la valeur byte en une valeur int en appelant la méthode Byte.toUnsignedInt() ou en la convertissant en primitive int, (int) signedByte & 0xFF. Ici vous avez un exemple:

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

Sortie

8-bit header:
10000000
11100010
01100000
11101010
0
Teocci