Convertir 4 bytes a int

Question

estoy leyendo un archivo binario como esto:

InputStream in = new FileInputStream(file); 
byte[] buffer = new byte[1024]; 
while((in.read(buffer) > -1) { 

    int a = // ??? 
} 

Lo que quiero hacer es leer hasta 4 bytes y crear un valor int de aquellos pero, no lo creo saber cómo hacerlo

Me siento como si tuviera que tomar 4 bytes a la vez, y llevar a cabo una operación "byte" (como < >> >> < & FF y cosas por el estilo) para crear el nuevo int

¿Cuál es el modismo para esto?

EDITAR

Lamentablemente este llegar a ser un poco más complejo (explicar)

Lo que estoy tratando de hacer es, leer un archivo (puede ser ASCII, binario, que doesn no importa) y extraer los enteros que pueda tener.

Por ejemplo supongamos que el contenido binario (en base 2):

00000000 00000000 00000000 00000001 
00000000 00000000 00000000 00000010 

La representación entera debe ser 1, 2 derecho? : -/1 para los primeros 32 bits, y 2 para los 32 bits restantes.

11111111 11111111 11111111 11111111 

sería -1

y

01111111 11111111 11111111 11111111 

sería Integer.MAX_VALUE (2147483647)

Answer 1

Usted debe ponerlo en una función como esta:

public static int toInt(byte[] bytes, int offset) { 
    int ret = 0; 
    for (int i=0; i<4 && i+offset<bytes.length; i++) { 
    ret <<= 8; 
    ret |= (int)bytes[i] & 0xFF; 
    } 
    return ret; 
} 

Ejemplo:

byte[] bytes = new byte[]{-2, -4, -8, -16}; 
System.out.println(Integer.toBinaryString(toInt(bytes, 0))); 

Salida:

11111110111111001111100011110000 

Este se encarga de quedarse sin bytes y correcta manipulación de los valores de byte negativos.

No conozco una función estándar para hacer esto.

cuestiones a considerar:

1. Endianness: diferentes arquitecturas de CPU ponen los bytes que componen un int en diferentes órdenes. Dependiendo de cómo se le ocurra la matriz de bytes para empezar, tal vez tenga que preocuparse por esto; y

2. Buffering: si coges 1024 bytes a la vez e inicia una secuencia en el elemento 1022 se alcanzó el final del búfer antes de llegar a 4 bytes.Probablemente sea mejor utilizar alguna forma de flujo de entrada en el búfer que haga el buffer automáticamente para que pueda simplemente usar readByte() repetidamente y no preocuparse de lo contrario;

3. Trailing Buffer: Al final de la entrada puede haber un número impar de bytes (no un múltiplo de 4 específicamente) según la fuente. Pero si creas la entrada para comenzar y ser un múltiplo de 4 está "garantizado" (o al menos una condición previa), es posible que no necesites preocuparte por ello.

estudiar más en detalle el punto de almacenamiento temporal, considere la BufferedInputStream:

InputStream in = new BufferedInputStream(new FileInputStream(file), 1024); 

Ahora usted tiene una InputStream que automáticamente buffers de 1024 bytes a la vez, lo cual es mucho menos difícil de tratar con. De esta forma, puede leer 4 bytes a la vez y no preocuparse por demasiada E/S.

En segundo lugar, también puede utilizar DataInputStream:

InputStream in = new DataInputStream(new BufferedInputStream(
        new FileInputStream(file), 1024)); 
byte b = in.readByte(); 

o incluso:

int i = in.readInt(); 

y no preocuparse por la construcción de int s en absoluto.

Answer 2

intentar algo como esto:

a = buffer[3]; 
a = a*256 + buffer[2]; 
a = a*256 + buffer[1]; 
a = a*256 + buffer[0]; 

esto es suponiendo que el byte más bajo viene primero. si el byte más alto aparece primero, es posible que deba cambiar los índices (pasar de 0 a 3).

básicamente para cada byte que desee agregar, primero multiplique por por 256 (que equivale a un desplazamiento a la izquierda por 8 bits) y luego agregue el nuevo byte.

Answer 3

La forma más sencilla es:

RandomAccessFile in = new RandomAccessFile("filename", "r"); 
int i = in.readInt(); 

- o -

DataInputStream in = new DataInputStream(new BufferedInputStream(
    new FileInputStream("filename"))); 
int i = in.readInt(); 

Answer 4

for (int i = 0; i < buffer.length; i++) 
{ 
    a = (a << 8) | buffer[i]; 
    if (i % 3 == 0) 
    { 
     //a is ready 
     a = 0; 
    }  
} 

Answer 5

ByteBuffer tiene esta capacidad, y es capaz de trabajar tanto con números enteros pequeños y grandes endian.

Considere este ejemplo:

 

// read the file into a byte array 
File file = new File("file.bin"); 
FileInputStream fis = new FileInputStream(file); 
byte [] arr = new byte[(int)file.length()]; 
fis.read(arr); 

// create a byte buffer and wrap the array 
ByteBuffer bb = ByteBuffer.wrap(arr); 

// if the file uses little endian as apposed to network 
// (big endian, Java's native) format, 
// then set the byte order of the ByteBuffer 
if(use_little_endian) 
    bb.order(ByteOrder.LITTLE_ENDIAN); 

// read your integers using ByteBuffer's getInt(). 
// four bytes converted into an integer! 
System.out.println(bb.getInt()); 
 

Espero que esto ayude.

Answer 6

acaba de ver cómo DataInputStream.readInt() está implementado;

int ch1 = in.read(); 
    int ch2 = in.read(); 
    int ch3 = in.read(); 
    int ch4 = in.read(); 
    if ((ch1 | ch2 | ch3 | ch4) < 0) 
     throw new EOFException(); 
    return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0)); 

Answer 7

Si los tiene ya en una matriz de bytes [], puede utilizar:

int result = ByteBuffer.wrap(bytes).getInt(); 

fuente: here

Answer 8

También puede utilizar BigInteger de bytes de longitud variable. Puede convertirlo en Largo, Entero o Corto, según sus necesidades.

new BigInteger(bytes).intValue(); 

o para indicar la polaridad:

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