Java: octets aux flotteurs / ints

J'ai un tableau d'octets envoyés via UDP à partir de x-plane. Les octets (4) sont tous des flotteurs ou des entiers...
J'ai essayé de les jeter à la flotte mais pas de chance jusqu'à présent...

Exemple de tableau:
de données byte[41] = { -66,30,73,0};

Comment puis-je convertir des 4 octets en int ou float et ne flotte pas l'utilisation de 8 octets?

source d'informationauteur JNK

23

Je ne sais pas le endianness de vos données. @dogbane la solution pourrait fonctionner. Sinon, en gros, vous avez besoin pour obtenir les octets dans un type int, selon l'ordre des octets, par exemple:
```
int asInt = (bytes[0] & 0xFF) 
            | ((bytes[1] & 0xFF) << 8) 
            | ((bytes[2] & 0xFF) << 16) 
            | ((bytes[3] & 0xFF) << 24);
```
Ensuite, vous pouvez transformer à un flotteur à l'aide de ceci:
```
float asFloat = Float.intBitsToFloat(asInt);
```
C'est essentiellement ce qu' DataInputStream n'sous les couvertures, mais il suppose que votre octets sont dans un certain ordre.

Modifier - Sur bit à Bit OU

L'OP a demandé des éclaircissements sur ce bit à bit OU fait dans ce cas. Alors que c'est un grand sujet qui pourrait être mieux étudiées de manière indépendante, je vais vous donner un bref bref. Ou (|) est un opérateur au niveau du bit dont le résultat est l'ensemble de bits individuellement ou-ing chaque bit des deux opérandes.

E. g. (en binaire)
```
   10100000
|  10001100
-----------
   10101100
```
Quand je suggère de l'utiliser au-dessus, il consiste à déplacer chaque octet dans une position unique dans l'int. Donc, si vous aviez les octets {0x01, 0x02, 0x03, 0x04}qui en binaire est {00000001, 00000010, 00000011, 00000100}vous avez ceci:
```
                                  0000 0001   (1)
                        0000 0010             (2 <<  8)
              0000 0011                       (3 << 16)
  | 0000 0100                                 (4 << 24)
  --------------------------------------------------------
    0000 0100 0000 0011 0000 0010 0000 0001   (67 305 985)
```
Lorsque vous OU deux chiffres et vous savoir que deux bits correspondants sont définies dans les deux (comme c'est le cas ici), OU au niveau du bit est le même que plus.

Voir Aussi
- Wikipédia: bit-à-Bit OU
20

Vous voudrez probablement faire usage de java.nio.ByteBuffer. Il a beaucoup de pratique des méthodes pour extraire les différents types d'un tableau d'octets, et doivent également traiter la plupart des problèmes de l'endianness pour vous (y compris le passage de l'octet de commande si nécessaire).
```
byte[] data = new byte[36]; 
//... populate byte array...

ByteBuffer buffer = ByteBuffer.wrap(data);

int first = buffer.getInt();
float second = buffer.getFloat();
```
Il a aussi des caractéristiques de fantaisie pour la conversion de votre tableau d'octets dans un tableau int (via un IntBuffer de la asIntBuffer() la méthode) ou float array (via un FloatBuffer de la asFloatBuffer ()) si vous savez que l'entrée est vraiment tous d'un type.

Utiliser un DataInputStream comme suit:

    DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data));
    float f = dis.readFloat();

    //or if it's an int:        
    int i = dis.readInt();

2

Vous ne pouvez pas les jeter dans un float/int. Vous devez convertir les octets dans un int ou float.

Voici une façon simple de le faire:
```
byte [] data = new byte[] {1,2,3,4};
ByteBuffer b = ByteBuffer.wrap(data);
System.out.println(b.getInt());
System.out.println(b.getFloat());
```
Il est raisonnable de discussion ici:

http://www.velocityreviews.com/forums/t129791-convert-a-byte-array-to-a-float.html

Vous devez vous connecter pour publier un commentaire.

Modifier - Sur bit à Bit OU

Voir Aussi