Comment convertir un octet en bits?

Question

J'ai un tableau d'octets. Je veux accéder à chacun des octets et vouloir sa valeur binaire équivalente (de 8 bits) afin d'y effectuer les opérations suivantes. J'ai entendu parler de BitSet mais y a-t-il un autre moyen de gérer cela?

Merci.

Answer 1

byte ar[] ; 
byte b = ar[0];//you have 8 bits value here,if I understood your Question correctly :) 

Answer 2

Si vous avez juste besoin de la représentation de chaîne de celui-ci en binaire, vous pouvez simplement utiliser Integer.toString() avec le second paramètre est réglé sur 2 pour binaire.

Pour effectuer des twittlings de bits généraux sur n'importe quel type intégral, vous devez utiliser des opérateurs logiques et de bitshift.

// tests if bit is set in value 
boolean isSet(byte value, int bit){ 
    return (value&(1<<bit))!=0; 
} 

// returns a byte with the required bit set 
byte set(byte value, int bit){ 
    return value|(1<<bit); 
} 

Answer 3

Java a bitwise operators. Voir a tutorial example.

Le langage de programmation Java fournit également des opérateurs qui effectuent des opérations bit à bit et de décalage de bits sur des types entiers. Les opérateurs discutés dans cette section sont moins couramment utilisés. Par conséquent, leur couverture est brève. l'intention est simplement de vous faire prendre conscience que ces opérateurs existent.

L'opérateur de complément de bits unaire "~" inverse un motif de bits; il peut être appliqué à l'un des types intégraux, faisant de chaque "0" un "1" et chaque "1" un "0". Par exemple, un octet contient 8 bits; l'application de cet opérateur à une valeur dont le modèle de bits est "00000000" changerait son modèle en "11111111".

Une valeur de byte EST intégrale, vous pouvez vérifier l'état d'un bit en utilisant des opérations de masquage. Le bit le moins significatif correspond au masque 1 ou 0x1, le bit suivant correspondent à 0x2, etc.

byte b = 3; 
if((b & 0x1) == 0x1) { 
    // LSB is on 
} else { 
    // LSB is off 
} 

Answer 4

Vous trouverez peut-être quelque chose le long des lignes de ce que vous cherchez dans le package Guava Primitives.

Alternativement, vous voudrez peut-être écrire quelque chose comme

public boolean[] convert(byte...bs) { 
boolean[] result = new boolean[Byte.SIZE*bs.length]; 
int offset = 0; 
for (byte b : bs) { 
    for (int i=0; i<Byte.SIZE; i++) result[i+offset] = (b >> i & 0x1) != 0x0; 
    offset+=Byte.SIZE; 
} 
return result; 
} 

Ce n'est pas testé, mais l'idée est là. Il y a aussi des modifications faciles aux boucles/affectation pour retourner un tableau de quelque chose d'autre (par exemple, int ou long).

Answer 5

BitSet.valueOf(byte[] bytes)

Vous pourriez avoir à jeter un oeil au code source comment il est mis en œuvre si vous n'utilisez pas java 7

Answer 6

Eh bien, je pense que j'obtenir ce que vous voulez dire. Maintenant, une erreur assez importante avec ceci est que cela ne fonctionne pas sur les nombres négatifs. Cependant, en supposant que vous ne l'utilisiez pas pour lire les entrées de fichiers, vous pouvez toujours l'utiliser.

public static ArrayList<Boolean> toBitArr(byte[] bytearr){ 
    ArrayList<Boolean> bitarr = new ArrayList<Boolean>(); 
    ArrayList<Boolean> temp = new ArrayList<Boolean>(); 
    int i = 0; 
    for(byte b: bytearr){ 
     while(Math.abs(b) > 0){ 
      temp.add((b % 2) == 1); 
      b = (byte) (b >> 1); 
     } 
     Collections.reverse(temp); 
     bitarr.addAll(temp); 
     temp.clear(); 
    } 
    return bitarr; 
}