Convierta una matriz de bytes a entero en Java y viceversa

Quiero almacenar algunos datos en conjuntos de bytes en Java. Básicamente solo números que pueden tomar hasta 2 Bytes por número.

Me gustaría saber cómo puedo convertir un número entero en una matriz de bytes de 2 bytes de largo y viceversa. Encontré muchas soluciones en Google, pero la mayoría de ellas no explican qué sucede en el código. Hay muchas cosas cambiantes que realmente no entiendo, así que agradecería una explicación básica.

Utilice las clases que se encuentran en el java.nioespacio de nombres, en particular, el ByteBuffer. Puede hacer todo el trabajo por ti.

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

Cuando se empaquetan bytes firmados en un int, cada byte debe enmascararse porque tiene un signo extendido a 32 bits (en lugar de cero extendido) debido a la regla de promoción aritmética (descrita en JLS, Conversiones y Promociones).

Hay un rompecabezas interesante relacionado con esto descrito en Java Puzzlers ("Una gran delicia en cada byte") de Joshua Bloch y Neal Gafter. Al comparar un valor de byte con un valor int, el byte se amplía con signo a un int y luego este valor se compara con el otro int

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

Tenga en cuenta que todos los tipos numéricos están firmados en Java, con la excepción de que char es un tipo entero sin signo de 16 bits.

También puede usar BigInteger para bytes de longitud variable. Puede convertirlo a largo, int o corto, lo que se ajuste a sus necesidades.

new BigInteger(bytes).intValue();

o para denotar polaridad:

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

Para recuperar bytes solo:

new BigInteger(bytes).toByteArray()

Una implementación básica sería algo como esto:

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 las cosas, puede leer este artículo de WP: http://en.wikipedia.org/wiki/Endianness

Se mostrará el código fuente anterior 34 12 78 56 bc 9a. Los primeros 2 bytes ( 34 12) representan el primer entero, etc. El código fuente anterior codifica enteros en 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;
    }

Alguien con un requisito en el que tiene que leer desde bits, digamos que tiene que leer desde solo 3 bits pero necesita un entero con signo y luego use lo siguiente:

data is of type: java.util.BitSet

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

El número mágico 3se puede reemplazar con el número de bits (no bytes) que está utilizando.

Como a menudo, la guayaba tiene lo que necesitas.

Para ir de una matriz de bytes a int: Ints.fromBytesArraydoc aquí

Para ir de la matriz de bytes a int: Ints.toByteArraydoc aquí

Creo que este es el mejor modo para enviar a int

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

primer byte convertido a String

comb=B+"";

el siguiente paso es convertir a un int

out= Integer.parseInt(comb);

pero el byte está en la rabia de -128 a 127 para esta razón, creo que es mejor usar la rabia de 0 a 255 y solo necesitas hacer esto:

out=out+256;