convertir - convert byte to integer java

Convierta una matriz de bytes a entero en Java y viceversa

Question

Quiero almacenar algunos datos en matrices 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 entero en una matriz de bytes largos de 2 bytes y viceversa. Encontré muchas soluciones en Google, pero la mayoría no explican lo que sucede en el código. Hay muchas cosas cambiantes que realmente no entiendo, por lo que agradecería una explicación básica.

Answer 1

Creo que este es un mejor modo para convertir 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 de compender a String

comb=B+"";

El próximo paso es comvertir a un int

out= Integer.parseInt(comb);

pero el byte está en rabia de -128 a 127 para este reasone, creo que es mejor usar rage 0 a 255 y solo necesitas hacer esto:

out=out+256;

Answer 2

También puede usar BigInteger para bytes de longitud variable. Puede convertirlo a largo, int o corto, según sus necesidades.

new BigInteger(bytes).intValue();

o para denotar la polaridad:

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

Para recuperar los bytes solo:

new BigInteger(bytes).toByteArray()

Answer 3

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

El código fuente anterior dará como resultado 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.

Answer 4

Utilice las clases que se encuentran en el espacio de nombre java.nio , 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 }

Answer 5

/** 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;
    }

Answer 6

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
int fromByteArray(byte[] bytes) {
     return bytes[0] << 24 | (bytes[1] & 0xFF) << 16 | (bytes[2] & 0xFF) << 8 | (bytes[3] & 0xFF);
}

Al empaquetar bytes con signo en un int, cada byte debe estar enmascarado porque está extendido por signo a 32 bits (en lugar de cero) 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 extiende 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 excepción de que char es un tipo de entero sin signo de 16 bits.