Блог

Используйте классы, найденные в 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: <<, amp;, | 
// 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] amp; 0xFF) << 16 | (bytes[2] amp; 0xFF) << 8 | (bytes[3] amp; 0xFF);
}

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

При упаковке байтов со знаком в int каждый байт должен быть замаскирован, поскольку он расширяется до 32 бит (а не расширяется до нуля) из-за правила арифметического продвижения (описано в JLS, Conversations 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 для байтов переменной длины. Вы можете преобразовать его в long, int или short, в зависимости от того, что вам подходит.

 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] amp; 0xff);
            output[j 1] = (byte)((input[i] >> 8) amp; 0xff);
        }

        for (int i = 0; i < output.length; i  )
            System.out.format("xn",output[i]);
    }
}
  

Чтобы понять, что вы можете прочитать эту статью WP: http://en.wikipedia.org/wiki/Endianness

Будет выведен приведенный выше исходный код 34 12 78 56 bc 9a . Первые 2 байта ( 34 12 ) представляют первое целое число и т.д. Приведенный выше исходный код кодирует целые числа в формате little endian.

 /** 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] amp; 0xFF);
        }
        return val;
    }
  

Как часто, в guava есть то, что вам нужно.

Чтобы перейти от массива байтов к int: Ints.fromBytesArray , doc здесь

Чтобы перейти от int к массиву байтов: Ints.toByteArray , документ здесь

У кого-то есть требование, при котором они должны читать из битов, допустим, вам нужно читать только из 3 битов, но вам нужно целое число со знаком, затем используйте следующее:

 data is of type: java.util.BitSet

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

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

я думаю, что это лучший способ для преобразования в int

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

первый comvert байт в строку

 comb=B "";
  

следующий шаг — преобразование в int

 out= Integer.parseInt(comb);
  

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

 out=out 256;