web-dev-qa-db-fra.com

Convertir un entier en tableau d'octets (Java)

qu'est-ce qu'un moyen rapide de convertir un Integer en un Byte Array?

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

javaarraysintegerbyte
129
Buttercup

Regardez 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 result[0] == 0xAA, result[1] == 0xBB, result[2] == 0xCC et result[3] == 0xDD.

Ou alternativement, 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 a été conçue pour ces tâches très sales. En fait, le privé Java.nio.Bits définit les 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); }
223
Gregory Pakosz

Utiliser BigInteger:

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

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

Utiliser ByteBuffer:

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

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

27
daz

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

Pour int → byte[], utilisez toByteArray() :

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

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

Son inversion 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.

15
Pang

Vous pouvez utiliser BigInteger:

Des entiers:

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

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. Cependant, la taille ne peut pas dépasser quatre octets si un int est passé.

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 dans ce cas), où BigInteger insèrerait un octet 0x00 au début du tableau. Ceci est nécessaire pour faire la distinction entre les valeurs positives et négatives.

8
notnoop

Cela vous aidera

importer Java.nio.ByteBuffer; importer Java.util.Arrays;

public class MyClass 
{
    public static void main(String args[]) {
       byte [] hbhbytes = ByteBuffer.allocate(4).putInt(16666666).array();

  System.out.println(Arrays.toString(hbhbytes));
    }
}
1
wai

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

De plus, la méthode Stringy:

public void getBytes(int val) {
    String hex = Integer.toHexString(val);
    byte[] val = new byte[hex.length()/2]; // because byte is 2 hex chars
    for (int i = 0; i < hex.length(); i+=2)
        val[i] = Byte.parseByte("0x" + hex.substring(i, i+2), 16);
    return val;
}
0
Muskovets

Peut aussi changer -

byte[] ba = new byte[4];
int val = Integer.MAX_VALUE;

for(byte i=0;i<4;i++)
    ba[i] = (byte)(val >> i*8);
    //ba[3-i] = (byte)(val >> i*8); //Big-endian
0
Matt

Voici une méthode qui devrait faire le travail juste.

public byte[] toByteArray(int value)
{
    final byte[] destination = new byte[Integer.BYTES];
    for(int index = Integer.BYTES - 1; index >= 0; index--)
    {
        destination[i] = (byte) value;
        value = value >> 8;
    };
    return destination;
};
0
user3424779