Konvertiert 4-Byte-int -

Bin ich beim Lesen einer Binär-Datei wie folgt:

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

   int a = //??? 
}

Was ich tun will, es zu Lesen, bis zu 4 bytes, und erstellen Sie ein int-Wert von denen, aber, ich weiß nicht, wie es zu tun.

Ich habe das Gefühl, ich muss packen 4 Byte zu einem Zeitpunkt, und führen Sie eine "byte" - Betrieb ( wie >> << >> & FF und sowas ) zum erstellen der neuen int

Was ist das idiom dafür?

BEARBEITEN

Ooops diese ein bisschen komplexer ( zu erklären )

Was ich versuche zu tun ist, Lesen Sie eine Datei ( ascii -, Binär -, ist es egal ), und extrahieren Sie die zahlen, die es haben kann.

Beispielsweise angenommen, die binären Inhalte ( Basis 2 ) :

00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010

Die integer-Darstellung sollte 1 , 2 Recht? :- /1 für die ersten 32 bits, und 2 für die restlichen 32 bits.

11111111 11111111 11111111 11111111

Wäre -1

und

01111111 11111111 11111111 11111111

Wäre Integer.MAX_VALUE ( 2147483647 )

InformationsquelleAutor der Frage OscarRyz | 2010-03-04

data-conversion java

ByteBuffer hat diese Fähigkeit und ist in der Lage, die Arbeit mit little-und big-endian-Integer.

Betrachten Sie dieses Beispiel:


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

Hoffe, das hilft.

InformationsquelleAutor der Antwort Tom

26

Sollten Sie es in eine Funktion wie diese:
```
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;
}
```
Beispiel:
```
byte[] bytes = new byte[]{ -2, -4, -8, -16};
System.out.println(Integer.toBinaryString(toInt(bytes, 0)));
```
Ausgabe:
```
11111110111111001111100011110000
```
Dieser kümmert sich um das laufen von bytes, die korrekt und Umgang mit negativen byte-Werte.

Ich bin mir nicht bewusst eine standard-Funktion, dies zu tun.

Aspekte zu berücksichtigen:
1. Endianness: verschiedenen CPU-Architekturen setzen Sie das Byte eines int in verschiedenen Ordnungen. Je nachdem, wie Sie kommen mit dem byte-array, um mit zu beginnen, die Sie haben können, zu sorgen; und
2. Pufferung: wenn Sie greifen 1024 bytes zu einer Zeit und starten Sie eine Sequenz-element 1022 Sie trifft das Ende des Puffers, bevor Sie um 4 bytes. Es ist wahrscheinlich besser, verwenden Sie irgendeine form von gepufferten Eingabestream wird, werden die gepufferten automatisch, so können Sie einfach readByte() wiederholt und Sie sich keine sorgen machen sonst;
3. Trailing-Puffer: das Ende der Eingabe kann eine ungerade Anzahl von bytes (auch nicht ein Vielfaches von 4, explizit) in Abhängigkeit von der Quelle. Aber wenn Sie die Eingabe beginnen, und die ein Vielfaches von 4 ist "garantiert" (oder zumindest Voraussetzung) können Sie nicht brauchen, um Bedenken Sie sich mit ihm.
näher auf den Punkt der Pufferung, sollten die BufferedInputStream:
```
InputStream in = new BufferedInputStream(new FileInputStream(file), 1024);
```
Nun haben Sie ein InputStream dass automatisch Puffer von 1024 Byte zu einem Zeitpunkt, das ist viel weniger umständlich zu handhaben. Auf diese Weise können Sie gerne Lesen 4 bytes zu einer Zeit, und sich keine sorgen über zu viel I/O.

Zweitens können Sie auch verwenden,DataInputStream:
```
InputStream in = new DataInputStream(new BufferedInputStream(
                     new FileInputStream(file), 1024));
byte b = in.readByte();
```
oder auch:
```
int i = in.readInt();
```
haben und sich keine Gedanken über den Bau ints bei allen.

InformationsquelleAutor der Antwort cletus
25

Wenn Sie diese bereits in ein byte[] array, die Sie verwenden können:
```
int result = ByteBuffer.wrap(bytes).getInt();
```
Quelle: hier

InformationsquelleAutor der Antwort iTEgg

nur noch sehen, wie DataInputStream.readInt() implementiert ist;

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

InformationsquelleAutor der Antwort Santhosh Kumar Tekuri

Der einfachste Weg ist:

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

-- oder --

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

InformationsquelleAutor der Antwort Taylor Leese

4

probieren Sie etwas wie dieses:
```
a = buffer[3];
a = a*256 + buffer[2];
a = a*256 + buffer[1];
a = a*256 + buffer[0];
```
dies ist unter der Annahme, dass der niedrigste byte zuerst kommt. wenn das höchste byte zuerst kommt, die Sie haben könnten, um die swap-Indizes (gehen von 0 bis 3).

grundsätzlich für jedes byte, das Sie hinzufügen möchten, multiplizieren Sie zunächst eine von 256 (das entspricht einer Verschiebung nach Links um 8 bits) und fügen Sie dann die neue byte.

InformationsquelleAutor der Antwort stmax

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

InformationsquelleAutor der Antwort Andrey

1

Können Sie auch verwenden, BigInteger für die variable "length" - Byte. Sie können konvertieren Sie es zu Lange, Integer oder Short, je nachdem, was Ihren Bedürfnissen entspricht.
```
new BigInteger(bytes).intValue();
```
oder zu bezeichnen, Polarität:
```
new BigInteger(1, bytes).intValue();
```
InformationsquelleAutor der Antwort Jamel Toms
0

Zum Lesen unsigned 4 Byte als integer-wir sollten nutzen, Sie eine long variable, da das Vorzeichen-bit betrachtet wird, als Teil der Zahl ohne Vorzeichen.
```
long result = (((bytes[0] << 8 & bytes[1]) << 8 & bytes[2]) << 8) & bytes[3]; 
result = result & 0xFFFFFFFF;
```
Getestet habe ich dies gut funktionierte Funktion

InformationsquelleAutor der Antwort Mounir

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.