ByteBuffer b =ByteBuffer.allocate(4);//b.order(ByteOrder.BIG_ENDIAN); // optional, the initial order of a byte buffer is always BIG_ENDIAN.
b.putInt(0xAABBCCDD);byte[] result = b.array();
Réglage de l' ordre des assure d'octets result[0] == 0xAA, result[1] == 0xBB, result[2] == 0xCCet result[3] == 0xDD.
La ByteBufferclasse a été conçue pour ces tâches de mains sales. En fait, le private java.nio.Bitsdéfinit ces méthodes d'assistance qui sont utilisées par ByteBuffer.putInt():
cela fonctionnerait bien si le bytebuffer est déjà là ... sinon il semble que cela prendrait plus de temps pour faire l'allocation, que d'allouer simplement un tableau d'octets de longueur 4 et de faire le décalage manuellement ... mais nous parlons probablement sur les petites différences.
Jason S
L'instance ByteBuffer peut être mise en cache; et en interne, il est sûrement mis en œuvre avec décalage et masquage de toute façon.
Gregory Pakosz
4
C'est une très bonne réponse. Notez que big-endian est la valeur par défaut spécifiée, et les méthodes sont "chaînables", et l'argument de position est facultatif, donc tout se réduit à: byte [] result = ByteBuffer.allocate (4) .putInt (0xAABBCCDD) .array ( ); Bien sûr, si vous faites cela à plusieurs reprises et concaténez tous les résultats ensemble (ce qui est courant lorsque vous faites ce genre de chose), allouez un seul tampon et mettez à plusieurs reprisesFoo () toutes les choses dont vous avez besoin - il gardera une trace du décalage au fur et à mesure. C'est vraiment une classe extrêmement utile.
Kevin Bourrillion
qu'est-ce que cela apporte aux types signés?
Gregory Pakosz
3
Pour qui ne sait pas. PutInt écrira toujours 4 octets, quelle que soit la taille de l'entier d'entrée. Si vous ne voulez que 2 octets, utilisez putShort, etc ...
bvdb
36
Utilisation BigInteger:
privatebyte[] bigIntToByteArray(finalint i ){BigInteger bigInt =BigInteger.valueOf(i);return bigInt.toByteArray();}
Utilisation DataOutputStream:
privatebyte[] intToByteArray (finalint i )throwsIOException{ByteArrayOutputStream bos =newByteArrayOutputStream();DataOutputStream dos =newDataOutputStream(bos);
dos.writeInt(i);
dos.flush();return bos.toByteArray();}
Utilisation ByteBuffer:
publicbyte[] intToBytes(finalint i ){ByteBuffer bb =ByteBuffer.allocate(4);
bb.putInt(i);return bb.array();}
@Pascal Utilisation de ByteBuffer J'ai essayé avec ByteBuffer bb = ByteBuffer.allocate (3); Pour cela, il donne java.nio.BufferOverflowException, je ne comprends pas pourquoi il ne fonctionne pas pour une valeur inférieure à 4? Pouvez-vous expliquer?
Sanjay Jain
@SanjayJain Vous obtenez une exception de dépassement de mémoire tampon car les entiers en Java ont une taille de 32 bits ou 4 octets et vous obligent donc à allouer au moins 4 octets de mémoire dans votre ByteBuffer.
choquant le
@GregoryPakosz a raison sur l'ordre des octets. Sa réponse en utilisant ByteBufferest plus intuitive si vous avez affaire à un int supérieur à 2 ^ 31 - 1.
Cela ne vaut rien non plus que cela fonctionne quel que soit le bit le plus significatif et plus efficace par rapport aux autres réponses. Peut également utiliser «>>».
algolicious le
1
Une solution directe comme celle-ci est certainement plus rapide que d'appeler une méthode de bibliothèque. Parfois, vous devez simplement manipuler les bits directement avec quelques lignes de code plutôt que d'encourir toute la surcharge supplémentaire des appels de méthode de bibliothèque.
David R Tribble
Et cela convertit bien les langues, ce qui est bon pour le développement de logiciels multilingues.
The Coordinator
15
Si vous aimez Guava , vous pouvez utiliser sa Intsclasse:
int intValue =Ints.fromByteArray(newbyte[]{(byte)0xAA,(byte)0xBB,(byte)0xCC,(byte)0xDD});int intValue =Ints.fromBytes((byte)0xAA,(byte)0xBB,(byte)0xCC,(byte)0xDD);
Le tableau retourné a la taille nécessaire pour représenter le nombre, il peut donc être de taille 1, pour représenter 1 par exemple. Toutefois, la taille ne peut pas être supérieure à quatre octets si un int est passé.
À partir de chaînes:
BigInteger v =newBigInteger("AABBCCDD",16);byte[] array = v.toByteArray();
Cependant, vous devrez faire attention, si le premier octet est plus élevé 0x7F(comme c'est le cas dans ce cas), où BigInteger insère un octet 0x00 au début du tableau. Ceci est nécessaire pour faire la distinction entre les valeurs positives et négatives.
Merci! Mais comme il s'agit de BigInteger, les ints s'enrouleront-ils correctement? Ce sont des entiers qui sont en dehors de Integer.MAX_VALUE mais peuvent toujours être représentés avec seulement 4 octets?
Buttercup
1
Ce n'est certainement pas rapide à exécuter. ;)
Peter Lawrey
Ce n'est pas une bonne option. Non seulement il peut ajouter l'octet 0x00, mais également supprimer les zéros non significatifs.
Voici une méthode qui devrait faire le travail correctement.
publicbyte[] toByteArray(int value){finalbyte[] destination =newbyte[Integer.BYTES];for(int index =Integer.BYTES -1; index >=0; index--){
destination[i]=(byte) value;
value = value >>8;};return destination;};
publicvoid getBytes(int val){byte[] bytes =newbyte[Integer.BYTES];for(int i =0;i < bytes.length; i ++){int j = val %Byte.MAX_VALUE;
bytes[i]=(j ==0?Byte.MAX_VALUE : j);}}
Aussi Stringy méthode:
publicvoid getBytes(int val){String hex =Integer.toHexString(val);byte[] val =newbyte[hex.length()/2];// because byte is 2 hex charsfor(int i =0; i < hex.length(); i+=2)
val[i]=Byte.parseByte("0x"+ hex.substring(i, i+2),16);return val;}
Réponses:
Jetez un œil à la classe ByteBuffer .
Réglage de l' ordre des assure d'octets
result[0] == 0xAA
,result[1] == 0xBB
,result[2] == 0xCC
etresult[3] == 0xDD
.Ou bien, vous pouvez le faire manuellement:
La
ByteBuffer
classe a été conçue pour ces tâches de mains sales. En fait, le privatejava.nio.Bits
définit ces méthodes d'assistance qui sont utilisées parByteBuffer.putInt()
:la source
Utilisation
BigInteger
:Utilisation
DataOutputStream
:Utilisation
ByteBuffer
:la source
ByteBuffer
est plus intuitive si vous avez affaire à un int supérieur à 2 ^ 31 - 1.utilise cette fonction ça marche pour moi
il traduit l'int en une valeur d'octet
la source
Si vous aimez Guava , vous pouvez utiliser sa
Ints
classe:Pour
int
→byte[]
, utiliseztoByteArray()
:Le résultat est
{0xAA, 0xBB, 0xCC, 0xDD}
.Son inverse est
fromByteArray()
oufromBytes()
:Le résultat est
0xAABBCCDD
.la source
Vous pouvez utiliser
BigInteger
:À partir des nombres entiers:
Le tableau retourné a la taille nécessaire pour représenter le nombre, il peut donc être de taille 1, pour représenter 1 par exemple. Toutefois, la taille ne peut pas être supérieure à quatre octets si un int est passé.
À partir de chaînes:
Cependant, vous devrez faire attention, si le premier octet est plus élevé
0x7F
(comme c'est le cas dans ce cas), où BigInteger insère un octet 0x00 au début du tableau. Ceci est nécessaire pour faire la distinction entre les valeurs positives et négatives.la source
Solution simple qui gère correctement ByteOrder:
ByteBuffer.allocate(4).order(ByteOrder.nativeOrder()).putInt(yourInt).array();
la source
très facile avec Android
la source
Cela vous aidera.
la source
Peut aussi changer -
la source
Voici une méthode qui devrait faire le travail correctement.
la source
C'est ma solution:
Aussi
String
y méthode:la source