Відповіді:
Погляньте на клас 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
Клас був розроблений для таких брудних рук завдань , хоча. Насправді приватний 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); }
Використання 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();
}
ByteBuffer
більш інтуїтивно, якщо ви маєте справу з
використовувати цю функцію, вона працює для мене
public byte[] toByteArray(int value) {
return new byte[] {
(byte)(value >> 24),
(byte)(value >> 16),
(byte)(value >> 8),
(byte)value};
}
це переводить int у значення байта
Якщо вам подобається 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
.
Ви можете використовувати BigInteger
:
Від цілих чисел:
byte[] array = BigInteger.valueOf(0xAABBCCDD).toByteArray();
System.out.println(Arrays.toString(array))
// --> {-86, -69, -52, -35 }
Повертається масив має той розмір, який потрібен для представлення числа, тому він може бути розміром 1, наприклад, 1. Однак розмір не може перевищувати чотирьох байтів, якщо передано інт.
З рядків:
BigInteger v = new BigInteger("AABBCCDD", 16);
byte[] array = v.toByteArray();
Однак вам потрібно буде стежити, якщо перший байт вищий 0x7F
(як у цьому випадку), куди BigInteger буде вставляти 0x00 байт на початок масиву. Це потрібно для розрізнення позитивних та негативних значень.
дуже легко з 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);
Ось метод, який повинен виконати роботу правильно.
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;
};
Це моє рішення:
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);
}
}
Також String
метод y:
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;
}