Entier Java à tableau d’octets

J’ai un nombre entier: 1695609641

quand j’utilise la méthode:

 Ssortingng hex = Integer.toHexSsortingng(1695609641); system.out.println(hex); 

donne:

 6510f329 

mais je veux un tableau d’octets:

 byte[] bytearray = new byte[] { (byte) 0x65, (byte)0x10, (byte)0xf3, (byte)0x29}; 

Comment puis-je faire ça?

utiliser ByteBuffer de Java NIO est très simple:

 byte[] bytes = ByteBuffer.allocate(4).putInt(1695609641).array(); for (byte b : bytes) { System.out.format("0x%x ", b); } 

sortie:

 0x65 0x10 0xf3 0x29 

Que diriez-vous:

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

L’idée n’est pas la mienne . Je l’ai pris à partir d’ un article sur dzone.com .

BigInteger.valueOf(1695609641).toByteArray()

 byte[] IntToByteArray( int data ) { byte[] result = new byte[4]; result[0] = (byte) ((data & 0xFF000000) >> 24); result[1] = (byte) ((data & 0x00FF0000) >> 16); result[2] = (byte) ((data & 0x0000FF00) >> 8); result[3] = (byte) ((data & 0x000000FF) >> 0); return result; } 

Utilisation de goyave :

 byte[] bytearray = Ints.toByteArray(1695609641); 
 byte[] conv = new byte[4]; conv[3] = (byte) input & 0xff; input >>= 8; conv[2] = (byte) input & 0xff; input >>= 8; conv[1] = (byte) input & 0xff; input >>= 8; conv[0] = (byte) input; 

Les morceaux ci-dessous fonctionnent au moins pour envoyer un int sur UDP.

int pour octet tableau:

 public byte[] intToBytes(int my_int) throws IOException { ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutput out = new ObjectOutputStream(bos); out.writeInt(my_int); out.close(); byte[] int_bytes = bos.toByteArray(); bos.close(); return int_bytes; } 

tableau d’octets à int:

 public int bytesToInt(byte[] int_bytes) throws IOException { ByteArrayInputStream bis = new ByteArrayInputStream(int_bytes); ObjectInputStream ois = new ObjectInputStream(bis); int my_int = ois.readInt(); ois.close(); return my_int; } 
 public static byte[] intToBytes(int x) throws IOException { ByteArrayOutputStream bos = new ByteArrayOutputStream(); DataOutputStream out = new DataOutputStream(bos); out.writeInt(x); out.close(); byte[] int_bytes = bos.toByteArray(); bos.close(); return int_bytes; } 

La classe org.apache.hadoop.hbase.util.Bytes possède un tas de méthodes pratiques de conversion des octets [], mais vous ne voudrez peut-être pas append la totalité du fichier HBase à votre projet uniquement à cette fin. Il est surprenant de constater que non seulement de telles méthodes ne contiennent pas l’AFAIK du JDK, mais aussi des bibliothèques évidentes telles que commons io.

Mon essai:

 public static byte[] toBytes(final int intVal, final int... intArray) { if (intArray == null || (intArray.length == 0)) { return ByteBuffer.allocate(4).putInt(intVal).array(); } else { final ByteBuffer bb = ByteBuffer.allocate(4 + (intArray.length * 4)).putInt(intVal); for (final int val : intArray) { bb.putInt(val); } return bb.array(); } } 

Avec cela vous pouvez faire ceci:

 byte[] fourBytes = toBytes(0x01020304); byte[] eightBytes = toBytes(0x01020304, 0x05060708); 

La classe complète est ici: https://gist.github.com/superbob/6548493 , elle prend en charge l’initialisation à partir de courts ou longs

 byte[] eightBytesAgain = toBytes(0x0102030405060708L); 

Comme vous voudrez généralement convertir ce tableau en int à un stade ultérieur, voici les méthodes pour convertir un tableau d’ints en un tableau d’octets et vice-versa:

 public static byte[] convertToByteArray(final int[] pIntArray) { final byte[] array = new byte[pIntArray.length * 4]; for (int j = 0; j < pIntArray.length; j++) { final int c = pIntArray[j]; array[j * 4] = (byte)((c & 0xFF000000) >> 24); array[j * 4 + 1] = (byte)((c & 0xFF0000) >> 16); array[j * 4 + 2] = (byte)((c & 0xFF00) >> 8); array[j * 4 + 3] = (byte)(c & 0xFF); } return array; } public static int[] convertToIntArray(final byte[] pByteArray) { final int[] array = new int[pByteArray.length / 4]; for (int i = 0; i < array.length; i++) array[i] = (((int)(pByteArray[i * 4]) << 24) & 0xFF000000) | (((int)(pByteArray[i * 4 + 1]) << 16) & 0xFF0000) | (((int)(pByteArray[i * 4 + 2]) << 8) & 0xFF00) | ((int)(pByteArray[i * 4 + 3]) & 0xFF); return array; } 

Notez qu'en raison de la propagation des signes, les "& 0xFF ..." sont nécessaires lors de la conversion en int.

 integer & 0xFF 

pour le premier octet

 (integer >> 8) & 0xFF 

pour la seconde et la boucle etc., écrire dans un tableau d’octets préalloué. Un peu en désordre, malheureusement.

Si vous utilisez apache-commons

 public static byte[] toByteArray(int value) { byte result[] = new byte[4]; return Conversion.intToByteArray(value, 0, result, 0, 4); }