Convertir un entier en tableau d’octets (Java)

Quel est le moyen rapide de convertir un Integer dans un Byte Array ?

par exemple 0xAABBCCDD => {AA, BB, CC, DD}

Jetez un oeil à la classe ByteBuffer .

 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(); 

Définir l’ordre des octets garantit que le result[0] == 0xAA , result[1] == 0xBB , result[2] == 0xCC et result[3] == 0xDD .

Ou bien, vous pouvez le faire manuellement:

 byte[] toBytes(int i) { byte[] result = new byte[4]; result[0] = (byte) (i >> 24); result[1] = (byte) (i >> 16); result[2] = (byte) (i >> 8); result[3] = (byte) (i /*>> 0*/); return result; } 

La classe ByteBuffer été conçue pour des tâches sales. En fait, le java.nio.Bits privé définit ces méthodes d’assistance utilisées par ByteBuffer.putInt() :

 private static byte int3(int x) { return (byte)(x >> 24); } private static byte int2(int x) { return (byte)(x >> 16); } private static byte int1(int x) { return (byte)(x >> 8); } private static byte int0(int x) { return (byte)(x >> 0); } 

Utiliser BigInteger :

 private byte[] bigIntToByteArray( final int i ) { BigInteger bigInt = BigInteger.valueOf(i); return bigInt.toByteArray(); } 

Utilisation de DataOutputStream :

 private byte[] intToByteArray ( final int i ) throws IOException { ByteArrayOutputStream bos = new ByteArrayOutputStream(); DataOutputStream dos = new DataOutputStream(bos); dos.writeInt(i); dos.flush(); return bos.toByteArray(); } 

En utilisant ByteBuffer :

 public byte[] intToBytes( final int i ) { ByteBuffer bb = ByteBuffer.allocate(4); bb.putInt(i); return bb.array(); } 

utiliser cette fonction ça marche pour moi

 public byte[] toByteArray(int value) { return new byte[] { (byte)(value >> 24), (byte)(value >> 16), (byte)(value >> 8), (byte)value}; } 

il traduit l’int en une valeur d’octet

Si vous aimez Guava , vous pouvez utiliser sa classe Ints :


Pour intbyte[] , utilisez toByteArray() :

 byte[] byteArray = Ints.toByteArray(0xAABBCCDD); 

Le résultat est {0xAA, 0xBB, 0xCC, 0xDD} .


Son inverse est fromByteArray() ou fromBytes() :

 int intValue = Ints.fromByteArray(new byte[]{(byte) 0xAA, (byte) 0xBB, (byte) 0xCC, (byte) 0xDD}); int intValue = Ints.fromBytes((byte) 0xAA, (byte) 0xBB, (byte) 0xCC, (byte) 0xDD); 

Le résultat est 0xAABBCCDD .

Vous pouvez utiliser BigInteger :

De entiers:

 byte[] array = BigInteger.valueOf(0xAABBCCDD).toByteArray(); System.out.println(Arrays.toSsortingng(array)) // --> {-86, -69, -52, -35 } 

Le tableau renvoyé est de la taille requirejse pour représenter le nombre, il pourrait donc être de taille 1, pour représenter 1 par exemple. Toutefois, la taille ne peut pas dépasser quatre octets si un entier est transmis.

De cordes:

 BigInteger v = new BigInteger("AABBCCDD", 16); byte[] array = v.toByteArray(); 

Cependant, vous devrez faire attention si le premier octet est supérieur à 0x7F (comme c’est le cas dans ce cas), où BigInteger insérera un octet 0x00 au début du tableau. Ceci est nécessaire pour distinguer les valeurs positives et négatives.

 static byte[] toBytes(int val, int bufferSize) { byte[] result = new byte[bufferSize]; for(int i = bufferSize - 1; i >= 0; i--) { result[i] = (byte) (val /*>> 0*/); val = (val >> 8); } return result; } 

// par jordaoesa e samirtf – meilleurs amis JFL <3

C’est ma solution:

 public void getBytes(int val) { byte[] bytes = new byte[Integer.BYTES]; for (int i = 0;i < bytes.length; i ++) { int j = val % Byte.MAX_VALUE; bytes[i] = (j == 0 ? Byte.MAX_VALUE : j); } } 

Je n'ai pas testé ce code - testez-le s'il vous plaît.
Ecrire résultat dans les commentaires

Cela vous aidera

import java.nio.ByteBuffer; import java.util.Arrays;

 public class MyClass { public static void main(Ssortingng args[]) { byte [] hbhbytes = ByteBuffer.allocate(4).putInt(16666666).array(); System.out.println(Arrays.toSsortingng(hbhbytes)); } }