Converter uma matriz de bytes em número inteiro em Java e vice-versa

Eu quero armazenar alguns dados em matrizes de bytes em Java. Basicamente, apenas números que podem levar até 2 bytes por número.

Gostaria de saber como converter um número inteiro em uma matriz de 2 bytes e vice-versa. Encontrei muitas soluções pesquisando no Google, mas a maioria delas não explica o que acontece no código. Há muitas coisas que eu realmente não entendo, então eu apreciaria uma explicação básica.

Use as classes encontradas no java.nioespaço para nome, em particular o ByteBuffer. Pode fazer todo o trabalho para você.

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

Ao compactar bytes assinados em um int, cada byte precisa ser mascarado porque é estendido para 32 bits (em vez de estendido para zero) devido à regra aritmética de promoção (descrita em JLS, Conversões e Promoções).

Há um quebra-cabeça interessante relacionado a isso descrito em Java Puzzlers ("Um grande prazer em todos os bytes") de Joshua Bloch e Neal Gafter. Ao comparar um valor de byte com um valor int, o byte é estendido para um int e, em seguida, esse valor é comparado ao outro int

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

Observe que todos os tipos numéricos são assinados em Java, com exceção do char sendo um tipo inteiro não assinado de 16 bits.

Você também pode usar o BigInteger para bytes de comprimento variável. Você pode convertê-lo para comprido, int ou curto, conforme a sua necessidade.

new BigInteger(bytes).intValue();

ou para denotar polaridade:

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

Para recuperar bytes apenas:

new BigInteger(bytes).toByteArray()

Uma implementação básica seria algo como isto:

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

Para entender as coisas, você pode ler este artigo do WP: http://en.wikipedia.org/wiki/Endianness

O código fonte acima será exibido 34 12 78 56 bc 9a. Os primeiros 2 bytes ( 34 12) representam o primeiro número inteiro etc. O código fonte acima codifica números inteiros no formato 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] & 0xFF);
        }
        return val;
    }

Alguém com um requisito onde eles precisam ler de bits, digamos que você precise ler apenas de 3 bits, mas você precisa de um número inteiro assinado e use o seguinte:

data is of type: java.util.BitSet

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

O número mágico 3pode ser substituído pelo número de bits (não bytes) que você está usando.

Com freqüência, goiaba tem o que você precisa.

Para passar da matriz de bytes para int Ints.fromBytesArray:, doc aqui

Para ir da matriz de int para byte:, Ints.toByteArraydoc aqui

Eu acho que este é o melhor modo de transmitir para int

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

primeiro byte de conversão para String

comb=B+"";

próximo passo é converter para um int

out= Integer.parseInt(comb);

mas byte está na faixa de -128 a 127 para este reasone, acho melhor usar a faixa de 0 a 255 e você só precisa fazer isso:

out=out+256;