Converti 4 byte in int

Sto leggendo un file binario come questo:

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

Quello che voglio farlo per leggere fino a 4 byte e creare un valore int da quelli, ma, non so come farlo.

Mi sento come se dovessi prendere 4 byte alla volta ed eseguire un’operazione “byte” (come >> <> & FF e cose del genere) per creare il nuovo int

Qual è l’idioma per questo?

MODIFICARE

    Ooops, questo risulta essere un po ‘più complesso (per spiegare)

    Quello che sto cercando di fare è leggere un file (potrebbe essere ascii, binario, non importa) ed estrarre gli interi che potrebbe avere.

    Ad esempio supponiamo il contenuto binario (in base 2):

     00000000 00000000 00000000 00000001 00000000 00000000 00000000 00000010 

    La rappresentazione intera dovrebbe essere 1 , 2 giusto? : – / 1 per i primi 32 bit e 2 per i restanti 32 bit.

     11111111 11111111 11111111 11111111 

    Sarebbe -1

    e

     01111111 11111111 11111111 11111111 

    Sarebbe Integer.MAX_VALUE ( 2147483647 )

    ByteBuffer ha questa capacità ed è in grado di lavorare con interi piccoli e grandi endian.

    Considera questo esempio:

    // 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());
    // 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()); 

    Spero che questo ti aiuti.

    Dovresti metterlo in una funzione come questa:

     public static int toInt(byte[] bytes, int offset) { int ret = 0; for (int i=0; i<4 && i+offset 

    Esempio:

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

    Produzione:

     11111110111111001111100011110000 

    Questo si occupa di esaurire i byte e gestire correttamente i valori di byte negativi.

    Non sono a conoscenza di una funzione standard per farlo.

    Problemi da considerare:

    1. Endianness: diverse architetture CPU mettono i byte che compongono un int in diversi ordini. A seconda di come si presenta la matrice di byte all'inizio, potrebbe essere necessario preoccuparsi di ciò; e

    2. Buffering: se si prendono 1024 byte alla volta e si avvia una sequenza all'elemento 1022, si raggiungerà la fine del buffer prima di ottenere 4 byte. Probabilmente è meglio usare qualche forma di stream di input bufferizzato che faccia automaticamente il buffered in modo da poter usare ripetutamente readByte() e non preoccuparsi altrimenti;

    3. Buffer finale: la fine dell'input può essere un numero dispari di byte (non un multiplo di 4 specificatamente) a seconda della sorgente. Ma se crei l'input per cominciare e se un multiplo di 4 è "garantito" (o almeno una precondizione) potresti non aver bisogno di occupartene.

    per approfondire ulteriormente il punto di buffering, considera BufferedInputStream :

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

    Ora avete un InputStream che InputStream automaticamente 1024 byte alla volta, il che è molto meno difficile da gestire. In questo modo puoi leggere felicemente 4 byte alla volta e non preoccuparti di troppo I / O.

    In secondo luogo è ansible utilizzare anche DataInputStream :

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

    o anche:

     int i = in.readInt(); 

    e non preoccuparti della costruzione di int s affatto.

    Se li hai già in una matrice di byte [], puoi usare:

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

    fonte: qui

    basta vedere come viene implementato DataInputStream.readInt ();

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

    Il modo più semplice è:

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

    — o —

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

    prova qualcosa come questo:

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

    questo presuppone che il byte più basso sia il primo. se il byte più alto viene prima, potrebbe essere necessario scambiare gli indici (andare da 0 a 3).

    fondamentalmente per ogni byte che si desidera aggiungere, prima si moltiplica a 256 (che equivale a uno spostamento a sinistra di 8 bit) e quindi si aggiunge il nuovo byte.

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

    È inoltre ansible utilizzare BigInteger per byte di lunghezza variabile. Puoi convertirlo in Long, Integer o Short, a seconda delle tue esigenze.

     new BigInteger(bytes).intValue(); 

    o per indicare la polarità:

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

    Per leggere 4 byte senza segno come numero intero dovremmo usare una variabile lunga, perché il bit di segno è considerato come parte del numero senza segno.

     long result = (((bytes[0] << 8 & bytes[1]) << 8 & bytes[2]) << 8) & bytes[3]; result = result & 0xFFFFFFFF; 

    Questo è testato funzione ben funzionante