Comment faire pour convertir un tableau d'octets à sa valeur numérique (Java)?

J'ai un 8 tableau d'octets, et je tiens à les convertir à sa correspondante de la valeur numérique.

par exemple

byte[] by = new byte[8];  //the byte array is stored in 'by'

//CONVERSION OPERATION
//return the numeric value

Je veux une méthode qui vous permettra d'effectuer ci-dessus opération de conversion.

Qu'entendez-vous par "valeur numérique"? Ne les octets représentent un nombre entier (long) ou nombre à virgule flottante (double) en binaire? Ils sont la représentation de chaîne d'un nombre? Ou encore une autre représentation?
Cela a été utile: stackoverflow.com/questions/5399798/...
NB: TacB0sS lien était ce que j'étais en fait à la recherche pour - à la fois en avant et en arrière de conversion.
new BigInteger(by).longValue()

InformationsquelleAutor pirate | 2009-06-22

100

En supposant que le premier octet est l'octet le moins significatif:
```
long value = 0;
for (int i = 0; i < by.length; i++)
{
   value += ((long) by[i] & 0xffL) << (8 * i);
}
```
Est le premier octet le plus significatif, c'est un peu différent:
```
long value = 0;
for (int i = 0; i < by.length; i++)
{
   value = (value << 8) + (by[i] & 0xff);
}
```
Remplacer longue avec BigInteger, si vous avez plus de 8 octets.

Grâce à Aaron Digulla pour la correction de mes erreurs.
- -1 octets sont des valeurs signées! Et remplacer pow() avec la touche shift (<<)! "valeur = (valeur << 8) + (par[i] & 0xff)"
- Vous êtes de droite. J'ai corrigé, j'espère que c'est maintenant correct.
- L'opérateur de décalage(<<) de droite à gauche, la priorité? Comment fonctionne le code ci-dessus fonctionne? Son travail tout va bien pour moi. Veux juste savoir le travail. Merci à l'avance
- L'opérateur de décalage(<<) de droite à gauche, la priorité? Comment fonctionne le code ci-dessus fonctionne? Son travail tout va bien pour moi. Veux juste savoir le travail. Merci à l'avance
- Dans le cas où quelqu'un d'autre a le même problème je n'ai, dans le premier exemple, le[i] doit être en fonte pour une longue, sinon il ne fonctionne que pour des valeurs inférieures à 2^32. C'est, value += ((long)by[i] & 0xffL) << (8 * i);
- J'ai inclus votre amélioration.
InformationsquelleAutor Mnementh
110

On pourrait utiliser la Tampons qui sont fournis dans le cadre de la java.nio package pour effectuer la conversion.

Ici, la source byte[] tableau de longueur 8, qui est la taille qui correspond à un long valeur.

Tout d'abord, le byte[] tableau est enveloppé dans un ByteBuffer, puis le ByteBuffer.getLong méthode est appelée pour obtenir le long valeur:
```
ByteBuffer bb = ByteBuffer.wrap(new byte[] {0, 0, 0, 0, 0, 0, 0, 4});
long l = bb.getLong();

System.out.println(l);
```
Résultat
```
4
```
Je tiens à remercier tfd pour souligner la ByteBuffer.getLong méthode dans les commentaires.

Bien qu'il peut ne pas être applicable dans cette situation, la beauté de la Buffers viennent avec, en regardant un tableau avec plusieurs valeurs.

Par exemple, si nous avons eu un 8 tableau d'octets, et nous avons voulu le voir comme deux int valeurs, nous avons pu envelopper le byte[] tableau dans une ByteBuffer, qui est considérée comme un IntBuffer et obtenir les valeurs par IntBuffer.get:
```
ByteBuffer bb = ByteBuffer.wrap(new byte[] {0, 0, 0, 1, 0, 0, 0, 4});
IntBuffer ib = bb.asIntBuffer();
int i0 = ib.get(0);
int i1 = ib.get(1);

System.out.println(i0);
System.out.println(i1);
```
Résultat:
```
1
4
```
- +1 pour le tableau avec les valeurs multiples
- qu'en est ByteBuffer.wrap(nouveau byte[] {0, 0, 0, 1, 0, 0, 0, 4}).getLong()? cette méthode doit lire le prochain de 8 octets et les convertir en un long
- Merci pour cette remarque, il semble que pour le travail -- je vais modifier la réponse. 🙂
InformationsquelleAutor coobird
16

Si c'est un 8 octets de valeur numérique, vous pouvez essayer:
```
BigInteger n = new BigInteger(byteArray);
```
Si c'est un caractère UTF-8 de la mémoire tampon, vous pouvez essayer:
```
BigInteger n = new BigInteger(new String(byteArray, "UTF-8"));
```
- J'aurais voté pour cette réponse si il a fini juste après le premier extrait de code, ou si elle comprenait un peu de code pour convertir la chaîne en une "valeur numérique". Que-est, la seconde moitié de votre réponse semble comme un non sequitur.
- Pas ce que je voulais en premier lieu, j'ai changé ma réponse
InformationsquelleAutor Vincent Robert
13

Simplement, vous pouvez utiliser ou de se référer à goyave lib fourni par google, qui offre utiliy méthodes pour la conversion entre le long et le tableau d'octets. Mon code client:
```
    long content = 212000607777l;
    byte[] numberByte = Longs.toByteArray(content);
    logger.info(Longs.fromByteArray(numberByte));
```
- google.github.io/goyave/releases/21.0/api/docs/com/google/common/...
InformationsquelleAutor Chen Yi
8

Vous pouvez également utiliser BigInteger pour la variable d'octets de longueur. Vous pouvez le convertir en Long, Entier ou Court, selon ce qui convient à vos besoins.
```
new BigInteger(bytes).intValue();
```
ou pour désigner la polarité:
```
new BigInteger(1, bytes).intValue();
```
InformationsquelleAutor Jamel Toms
3

Java complet convertisseur de code pour tous les types primitifs à/à partir de baies
http://www.daniweb.com/code/snippet216874.html

InformationsquelleAutor iBog
1

Chaque cellule de la matrice est considérée comme unsigned int:
```
private int unsignedIntFromByteArray(byte[] bytes) {
int res = 0;
if (bytes == null)
    return res;


for (int i=0;i<bytes.length;i++){
    res = res | ((bytes[i] & 0xff) << i*8);
}
return res;
}
```
- Juste une remarque que j'avais besoin d'utiliser 0xFFL, sinon le cast int 0xFF pour longtemps eu beaucoup de mauvaise bits à 1 lorsque j'Longues imprimé.toHexString(l).
- Vous avez besoin d'utiliser 0xFFL sinon vous aurez l'extension du signe.
InformationsquelleAutor Asaf Pinhassi

Vous devez vous connecter pour publier un commentaire.