Convertir entero en matriz de bytes (Java)

¿Cuál es una forma rápida de convertir un Integeren un Byte Array?

p.ej 0xAABBCCDD => {AA, BB, CC, DD}

Echa un vistazo a la clase 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();

Configuración garantiza el orden de bytes que result[0] == 0xAA, result[1] == 0xBB, result[2] == 0xCCy result[3] == 0xDD.

O, alternativamente, puede hacerlo manualmente:

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

Sin ByteBufferembargo, la clase fue diseñada para tareas tan sucias. De hecho, lo privado java.nio.Bitsdefine estos métodos auxiliares que son utilizados por 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); }

Utilizando BigInteger:

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

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

Utilizando ByteBuffer:

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

usa esta función me funciona

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

traduce el int en un valor de byte

Si te gusta la guayaba , puedes usar su Intsclase:

Para int→ byte[], use toByteArray():

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

El resultado es {0xAA, 0xBB, 0xCC, 0xDD}.

Su reverso es fromByteArray()o 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);

El resultado es 0xAABBCCDD.

Puedes usar BigInteger:

De enteros:

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

La matriz devuelta es del tamaño que se necesita para representar el número, por lo que podría ser del tamaño 1, para representar 1, por ejemplo. Sin embargo, el tamaño no puede ser más de cuatro bytes si se pasa un int.

De cuerdas:

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

Sin embargo, deberá tener cuidado, si el primer byte es mayor 0x7F(como en este caso), donde BigInteger insertaría un byte 0x00 al comienzo de la matriz. Esto es necesario para distinguir entre valores positivos y negativos.

Solución simple que maneja adecuadamente ByteOrder:

ByteBuffer.allocate(4).order(ByteOrder.nativeOrder()).putInt(yourInt).array();

muy fácil con android

int i=10000;
byte b1=(byte)Color.alpha(i);
byte b2=(byte)Color.red(i);
byte b3=(byte)Color.green(i);
byte b4=(byte)Color.blue(i);

Esto te ayudara.

import java.nio.ByteBuffer;
import 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));
    }
}

También puede cambiar

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

Aquí hay un método que debería hacer el trabajo correctamente.

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

Es mi solucion:

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

También Stringy método:

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