Octets en Java?

Question

Merci pour toutes les réponses ci-dessus, mais n'a pas vraiment m'aider juste pour donner une idée de ce que je veux faire exactement: Je code pour une sorte de paquet qui a différents champs avec longueur différente en octets

ainsi field1 est 2 octets long field2 est 3 octets long field3 est 6 octets de long et quand j'ajoute ces champs, je devrais obtenir 11 octets de longueur ...

Mais je ne sais pas comment puis-je déclarer quelque chose avec cet octet long ...

Veuillez nous aider ... merci d'avance

Answer 1

Utilisez un tableau:

byte[] byteArray = new byte[11]; 

Answer 2

Comment est sur:

byte[] arr = new byte[11]; 

Answer 3

J'ai trouvé que java.nio.ByteBuffer est généralement meilleur pour ce genre de chose. Il a de bonnes méthodes pour traiter l'interprétation des octets dans le tampon. Les documents sont here.

import java.nio.ByteBuffer; 

ByteBuffer buffer = ByteBuffer.allocate(11); 

Vérifiez les docs et regarder les belles méthodes telles que getInt() et getChar().

Answer 4

Java a une collection limitée de types primitifs, qui ont tous une taille fixe. Vous pouvez voir une liste d'entre eux here. Cela signifie que vous ne pouvez pas décider du nombre d'octets de votre variable. Comme d'autres l'ont déjà mentionné, vous pouvez toujours créer un new byte[11]. Notez que Java byte est signé, cependant. Il va de -128 à 127, pas de 0 à 255.

Answer 5

Vous pouvez utiliser une classe pour représenter votre paquet:

public class Packet 
{ 
    public byte[] Field1, Field2, Field3; 

    public Packet(byte[] packetBytes) 
    { 
     ByteBuffer packet = ByteBuffer.wrap(packetBytes); 
     Field1 = new byte[2]; 
     Field2 = new byte[3]; 
     Field3 = new byte[6]; 
     packet.get(Field1, 0, 2); 
     packet.get(Field2, 2, 3); 
     packet.get(Field3, 5, 6); 
    } 
} 

ByteBuffer est bon pour octet manipulation.

Answer 6

Je recommande les classes d'utilitaires au Javolution pour traiter les flux de protocoles binaires tels que celui-ci. Ils m'ont été utiles à plusieurs reprises pour traiter des flux binaires de bas niveau.

Answer 7

Vous devriez probablement concevoir votre code pour séparer le message que vous voulez manipuler dans Java du format de niveau de fil dont vous avez besoin de lire/écrire.

par exemple. Si vous avez un concept screenresolution, vous pouvez le représenter en Java avec une classe screenresolution:

public class ScreenResolution { 
    public int height; 
    public int width; 
} 

Cette classe est facile de travailler avec Java. Transformer ceci en un paquet qui peut être transmis sur un réseau/enregistré dans un fichier, etc. selon un format de fichier ou un protocole est une autre préoccupation. Dites la hauteur et la largeur doit être aménagé en 3 octets chacun, avec une pièce d'identité et de la longueur pour le « format fil », vous faites quelque chose comme

public byte[] marshalScreenResolution(ScreenResolution obj) { 
    byte[] buf = new byte[9]; 
//length of this packet, 2 bytes 
    buf[0] = 0; 
    buf[1] = 9; 
    buf[2] = SCREENRESOLUTION_OPCODE; 
    //marshal the height/width , 3 least significant bytes. 
    buf[3] = (obj.height&0xff0000) >> 16; 
    buf[4] = (obj.height&0x00ff00) >> 8; 
    buf[5] = (obj.height&0x0000ff) ; 
    buf[6] = (obj.width&0xff0000) >> 16; 
    buf[7] = (obj.width&0x00ff00) >> 8; 
    buf[8] = (obj.width&0x0000ff) ; 

    return buf; 
} 

et vous faire une fonction demarshalScreenResolution pour aller d'un paquet à un objet ScreenResolution. Le point est que vous découplez la représentation en java de la représentation externe, et que vous assemblez les champs dans la représentation externe en utilisant des octets + quelques bits de base.