Преобразование целочисленного в байтовый массив (Java)

Ответ 1

Посмотрите на 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();

Установка порядка байтов гарантирует, что result[0] == 0xAA, result[1] == 0xBB, result[2] == 0xCC и result[3] == 0xDD.

Или, альтернативно, вы можете сделать это вручную:

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

Класс ByteBuffer был разработан для таких задач с грязными руками. Фактически private java.nio.Bits определяет эти вспомогательные методы, которые используются 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); }

Ответ 2

Использование BigInteger:

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

Использование 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();
}

Использование ByteBuffer:

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

Ответ 3

используйте эту функцию, она работает для меня

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

он преобразует int в байтовое значение

Ответ 4

Если вам нравится Guava, вы можете использовать класс Ints:

Для int → byte[] используйте toByteArray():

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

Результат {0xAA, 0xBB, 0xCC, 0xDD}.

Его обратная сторона fromByteArray() или 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);

Результат 0xAABBCCDD.

Ответ 5

Вы можете использовать BigInteger:

От целых чисел:

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

Возвращаемый массив имеет размер, необходимый для представления числа, поэтому он может быть размером 1, чтобы представлять 1, например. Тем не менее, размер не может быть больше четырех байтов, если передан int.

Из строк:

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

Однако вам нужно будет следить, если первый байт выше 0x7F (как в этом случае), где BigInteger вставляет 0x00 байт в начало массива. Это необходимо для различения положительных и отрицательных значений.

Ответ 6

Вот метод, который должен делать эту работу как раз правильно.

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

Ответ 7

Это мое решение:

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

Ответ 8

Это поможет вам

импорт 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));
    }
}

Ответ 9

Можно также сдвинуть -

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