Перетворити масив байтів у цілі числа в Java та навпаки

Я хочу зберігати деякі дані в байтових масивах на Java. В основному просто числа, які можуть займати до 2 байт на число.

Мені хотілося б знати, як я можу перетворити ціле число в 2-байтний байтовий масив і навпаки. Я знайшов багато рішень, що гуглить, але більшість з них не пояснюють, що відбувається в коді. Є багато змін, які я не дуже розумію, тому я буду вдячний за основне пояснення.

Використовуйте класи, знайдені в java.nioпросторі імен, зокрема ByteBuffer. Це може зробити всю роботу за вас.

byte[] arr = { 0x00, 0x01 };
ByteBuffer wrapped = ByteBuffer.wrap(arr); // big-endian by default
short num = wrapped.getShort(); // 1

ByteBuffer dbuf = ByteBuffer.allocate(2);
dbuf.putShort(num);
byte[] bytes = dbuf.array(); // { 0, 1 }

byte[] toByteArray(int value) {
     return  ByteBuffer.allocate(4).putInt(value).array();
}

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

int fromByteArray(byte[] bytes) {
     return ByteBuffer.wrap(bytes).getInt();
}
// packing an array of 4 bytes to an int, big endian, minimal parentheses
// operator precedence: <<, &, | 
// when operators of equal precedence (here bitwise OR) appear in the same expression, they are evaluated from left to right
int fromByteArray(byte[] bytes) {
     return bytes[0] << 24 | (bytes[1] & 0xFF) << 16 | (bytes[2] & 0xFF) << 8 | (bytes[3] & 0xFF);
}

// packing an array of 4 bytes to an int, big endian, clean code
int fromByteArray(byte[] bytes) {
     return ((bytes[0] & 0xFF) << 24) | 
            ((bytes[1] & 0xFF) << 16) | 
            ((bytes[2] & 0xFF) << 8 ) | 
            ((bytes[3] & 0xFF) << 0 );
}

Під час упаковки підписаних байтів у int кожен байт потрібно замаскувати, оскільки він розширений знаком до 32 біт (а не нульовим розширенням) завдяки правилу арифметичного просування (описаному в JLS, Conversions and Promotions).

Є цікава головоломка, пов’язана з цим, описаним у Java Puzzlers ("Велике захоплення в кожному байті") Джошуа Блоха та Ніла Гафтера. Порівнюючи значення байта зі значенням int, байт розширюється на int, а потім це значення порівнюється з іншим int

byte[] bytes = (…)
if (bytes[0] == 0xFF) {
   // dead code, bytes[0] is in the range [-128,127] and thus never equal to 255
}

Зауважте, що всі числові типи підписані на Java, за винятком того, що char є 16-бітовим цілим числом без підпису.

Також ви можете використовувати BigInteger для байтів змінної довжини. Ви можете перетворити його на довгий, інт або короткий, залежно від ваших потреб.

new BigInteger(bytes).intValue();

або для позначення полярності:

new BigInteger(1, bytes).intValue();

Щоб повернути байти просто:

new BigInteger(bytes).toByteArray()

Основна реалізація буде приблизно такою:

public class Test {
    public static void main(String[] args) {
        int[] input = new int[] { 0x1234, 0x5678, 0x9abc };
        byte[] output = new byte[input.length * 2];

        for (int i = 0, j = 0; i < input.length; i++, j+=2) {
            output[j] = (byte)(input[i] & 0xff);
            output[j+1] = (byte)((input[i] >> 8) & 0xff);
        }

        for (int i = 0; i < output.length; i++)
            System.out.format("%02x\n",output[i]);
    }
}

Щоб зрозуміти речі, ви можете прочитати цю статтю WP: http://en.wikipedia.org/wiki/Endianness

Вище наведений вихідний код виведе 34 12 78 56 bc 9a. Перші 2 байти ( 34 12) представляють перше ціле число тощо. Вище наведений вихідний код кодує цілі числа у форматі маленького ендіану.

/** length should be less than 4 (for int) **/
public long byteToInt(byte[] bytes, int length) {
        int val = 0;
        if(length>4) throw new RuntimeException("Too big to fit in int");
        for (int i = 0; i < length; i++) {
            val=val<<8;
            val=val|(bytes[i] & 0xFF);
        }
        return val;
    }

Хтось із вимогою, коли вони повинні читати з бітів, скажемо, що ви повинні читати лише з 3 біт, але вам потрібно підписати ціле число, а потім використовувати наступне:

data is of type: java.util.BitSet

new BigInteger(data.toByteArray).intValue() << 32 - 3 >> 32 - 3

Магічне число 3можна замінити кількістю використовуваних бітів (не байтів) .

Як часто у гуави є те, що потрібно.

Щоб перейти з масиву байтів до int:, Ints.fromBytesArraydoc тут

Щоб перейти від int до байтового масиву:, Ints.toByteArraydoc тут

Я думаю, що це найкращий режим для передачі Int

   public int ByteToint(Byte B){
        String comb;
        int out=0;
        comb=B+"";
        salida= Integer.parseInt(comb);
        out=out+128;
        return out;
    }

перший байт конвертувати в String

comb=B+"";

Наступний крок - перетворення в int

out= Integer.parseInt(comb);

але байт знаходиться в гніві від -128 до 127 для цього міркування, я думаю, краще використовувати лють 0 до 255, і вам потрібно лише зробити це:

out=out+256;