Convertir Octet binaire en Java

Je suis en train de convertir une valeur d'un octet binaire pour le transfert de données. En gros, je suis l'envoi d'une valeur comme "AC" en binaire ("10101100") dans un tableau d'octets où "10101100" est un seul octet. Je veux être en mesure de recevoir cet octet et le reconvertir en "10101100." Dès à présent je n'ai pas de succès à tous de ne pas vraiment savoir par où commencer. Toute aide serait super.

modifier: désolé pour la confusion, je n'ai pas de réaliser que j'ai oublié d'ajouter plus de détails.

Essentiellement, j'ai besoin d'utiliser un tableau d'octets à envoyer des valeurs binaires sur une connexion de socket. Je peux le faire mais je ne sais pas comment convertir les valeurs et les faire apparaître correctement. Voici un exemple:

J'ai besoin d'envoyer les valeurs hexadécimales ACDE48 et être en mesure de l'interpréter en arrière. Selon la documentation, je dois le convertir en binaire de la manière suivante: byte [] b={10101100,11011110,01001000}, où chaque place dans le tableau peut contenir 2 valeurs. J'ai donc besoin de convertir ces valeurs de retour après ils sont envoyés et reçus. Je ne suis pas sûr de savoir comment aller à ce sujet.

Que voulez-vous dire "binaire"? Toutes les valeurs sont stockées dans des fichiers binaires (comme ils sont assis dans les transistors avec un 1 ou 0 etat de toute façon). Il n'y a aucun moyen que vous voulez vraiment une chaîne ASCII de "10101100", est-il?!
Vous voulez une chaîne avec la valeur "10101100" ou si vous voulez une variable d'octet contenant ce nombre?
Tangentielle question: avez-vous une raison pour laquelle vous êtes à la main, le laminage à votre propre sérialisation binaire au lieu d'utiliser l'un des grand nombre de formats standard qui viennent avec un support de bibliothèque?
De quelle manière? 0xAC == binaire 10101100.
Je pense que vous prenez les citations trop littéralement. 0xAC == 0b10101100

OriginalL'auteur user1506919 | 2012-07-17

15
```
String toBinary( byte[] bytes )
{
    StringBuilder sb = new StringBuilder(bytes.length * Byte.SIZE);
    for( int i = 0; i < Byte.SIZE * bytes.length; i++ )
        sb.append((bytes[i / Byte.SIZE] << i % Byte.SIZE & 0x80) == 0 ? '0' : '1');
    return sb.toString();
}

byte[] fromBinary( String s )
{
    int sLen = s.length();
    byte[] toReturn = new byte[(sLen + Byte.SIZE - 1) / Byte.SIZE];
    char c;
    for( int i = 0; i < sLen; i++ )
        if( (c = s.charAt(i)) == '1' )
            toReturn[i / Byte.SIZE] = (byte) (toReturn[i / Byte.SIZE] | (0x80 >>> (i % Byte.SIZE)));
        else if ( c != '0' )
            throw new IllegalArgumentException();
    return toReturn;
}
```
Il y a quelques moyens plus simples pour gérer cela aussi (ce qui suppose que big endian).
```
Integer.parseInt(hex, 16);
Integer.parseInt(binary, 2);
```
et
```
Integer.toHexString(byte).subString((Integer.SIZE - Byte.SIZE) / 4);
Integer.toBinaryString(byte).substring(Integer.SIZE - Byte.SIZE);
```
Vous devez spécifier au moins comment l'ordre des bits dans la chaîne de caractères se rapportent à l'ordre des bits dans le tableau d'octets, d'autant plus que votre commande semble non-standard. Vous pouvez réellement écrire fromBinary() sans si des déclarations qui devraient accélérer la vitesse de votre code un peu. StringBuilder peut être prêtes pour la taille correcte par la fourniture de la taille dans le constructeur (bytes.length * Byte.SIZE). Enfin, votre fromBinary accepte les chaînes non valides, par exemple, des chiffres de valeur '2' est traduit en une valeur nulle bits.
Je suis confus quant à pourquoi vous croyez que l'ordre des bits est non-standard. C'est le MSB en premier, mais en raison du fait que les octets sont signés vous avez des problèmes avec représentation décimale si le MSB est réglé. J'ai également ajouté presque tout ce que vous avez mentionné.
C'est de l'ESM pour chaque octet, avec l'indice le plus bas en premier. Vous aurez donc la plus faible octet de poids fort en premier, avec l'ordre le plus élevé de bits en premier. C'est très bien, mais j'ai de la documentation de ces choses avec soin (mais je suis un pain PITA au sujet des détails tels). C'est gentil à vous de faire les changements!
Je ne vois pas où endianness vient ici. Les octets sont jamais réunis, donc je ne sais pas où vous êtes obtenir le plus bas de l'ordre des bits est le premier.
Vous pouvez encore commander les octets de gauche à droite ou de droite à gauche, ne pouvez-vous pas?

OriginalL'auteur LINEMAN78

Pour la conversion hexadécimal en binaire, vous pouvez utiliser BigInteger pour simplifier votre code.

public static void sendHex(OutputStream out, String hexString) throws IOException {
    byte[] bytes = new BigInteger("0" + hexString, 16).toByteArray();
    out.write(bytes, 1, bytes.length-1);
}

public static String readHex(InputStream in, int byteCount) throws IOException {
    byte[] bytes = new byte[byteCount+1];
    bytes[0] = 1;
    new DataInputStream(in).readFully(bytes, 1, byteCount);
    return new BigInteger(0, bytes).toString().substring(1);
}

Octets sont envoyés sous forme binaire, sans traduction. Il fait ses la seulement type qui n'a pas besoin d'une forme de codage. Comme il n'y a rien à faire.

À écrire un octet en binaire

OutputStream out = ...
out.write(byteValue);

InputStream in = ...
int n = in.read();
if (n >= 0) {
   byte byteValue = (byte) n;

je pense que l'OP est aussi confus comment la chaîne hexadécimale "ACDE48" correspond à un tableau d'octets.

OriginalL'auteur Peter Lawrey

Alternative à @LINEMAN78s solution est:

public byte[] getByteByString(String byteString){
    return new BigInteger(byteString, 2).toByteArray();
}

public String getStringByByte(byte[] bytes){
    StringBuilder ret  = new StringBuilder();
    if(bytes != null){
        for (byte b : bytes) {
            ret.append(Integer.toBinaryString(b & 255 | 256).substring(1));
        }
    }
    return ret.toString();
}

OriginalL'auteur lidox

Vous devez vous connecter pour publier un commentaire.