# int aus Byte-Array erzeugen



## hugo (27. Jan 2005)

Ich habe eine int-Zahl in einem Byte-Array gespeichert. Aus diesen Bytes möchte ich jetzt den int wieder zusammensetzen. Derzeit mache ich das wie folgt:

```
byte[] Header = new byte[4];
// Header wird vor dem nächsten Befehl mit der Zahl 31635 gefüllt
int Serie = (Header[3] << 24) + (Header[2] << 16) + (Header[1] << 8) + (Header[0]);
```
Kommt auch eine halbwegs vernünftige Zahl raus, bloß dass das letzte Bit des dritten Bytes falsch ist.
So wird aus ehemals 31635 --> 31379. Woran liegt das?


----------



## The_S (27. Jan 2005)

Wie hast du den int auf die byte-Array aufgeteilt? Hast du 123 in 1 2 3 geteilt oder z. B. in 100 20 3?


----------



## hugo (27. Jan 2005)

Ein int ist ja eine 4 Byte Zahl und diese 4 Bytes habe ich auf das Array verteilt.


```
int SerienNrInt = 31635;          
Integer neuerInt = new Integer(SerienNrInt >> 24);
Header[3] = neuerInt.byteValue();
neuerInt = new Integer(SerienNrInt >> 16);
Header[2] = neuerInt.byteValue();
neuerInt = new Integer(SerienNrInt >> 8);
Header[1] = neuerInt.byteValue();
neuerInt = new Integer(SerienNrInt);
Header[0] = neuerInt.byteValue();
```


----------



## The_S (27. Jan 2005)

In dem Fall: Ich hab keine Ahnung (hab auch erst mit proggen angefangen). Sorry  :bahnhof:


----------



## hugo (27. Jan 2005)

Also eins habe ich noch herausbekommen, wenn das oberste Bit des letzten Byte "1" ist, wird das unterse Bit des 3. Byte getauscht. Wenn das oberste Bit des letzten Byte "0" ist, wird die richtige Zahl übertragen.


----------



## helium (27. Jan 2005)

Verwende statt >> mal >>>


----------



## hugo (27. Jan 2005)

Du hast mit deinem Vorschlag sicherlich recht, bloß war das nur zur Veranschaulichung. Ich lese die Bytes aus einem Datenstrom in das Feld ein, also die Bytes an sich sollten richtig bei mir ankommen.


----------



## hugo (27. Jan 2005)

So habe jetzt eine Lösung zu dem Problem:

```
int Eins = (int)(Header[3] & 0xFF) * 16777216;
int Zwei = (int)(Header[2] & 0xFF) * 65536;
int Drei = (int)(Header[1] & 0xFF) * 256;
int Vier = (int)(Header[0] & 0xFF);
int Serie = Eins + Zwei + Drei + Vier;
```

Falls jemand eine elegantere oder ressourcenschonendere Variante kennt immer her damit.

hugo


----------



## Kampfturtle (21. Jul 2005)

```
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
.
.
.
int erg = ((ByteBuffer.wrap(b)).order(ByteOrder.LITTLE_ENDIAN)).getInt();
```

bestimmt nicht ressourcenschonender aber man kann durch ByteOrder mal schnell auf ein anderes System anpassen. Weiterhin kann man aus einem ByteBuffer mit .getShort(), .getDouble() etc. aus einem ByteArray (sollte natürlich eine sinnvolle länge haben und richtig initialiisert worden sein) ein Short, Double .. etc. machen.

http://java.sun.com/j2se/1.4.2/docs/api/java/nio/ByteBuffer.html


----------



## sisko78 (21. Jul 2005)

```
int SerienNrInt = 31635;         
Integer neuerInt = new Integer(SerienNrInt >> 24);
Header[3] = neuerInt.byteValue();
neuerInt = new Integer(SerienNrInt >> 16);
Header[2] = neuerInt.byteValue();
neuerInt = new Integer(SerienNrInt >> 8);
Header[1] = neuerInt.byteValue();
neuerInt = new Integer(SerienNrInt);
Header[0] = neuerInt.byteValue();
```

irgendwas hab ich da nicht ganz verstanden:

Das erste byte ist voller 0en
Das zweite auch
Das 3. enthält die höherwertigen 8 bits des Integers
nd das 4. enthält die komplette bitrepräsentation des integers 

wenn ich die addiere ist doch klar, dass da einmal die 255 der ersten 8 bits mehr rauskommt oder wo ist mein Denkfehler?
Edit: ach wird ja weniger, jetzt blick ichs gar nicht mehr
nochmal edit: post einfach ignorieren, habs nochmal angeschaut, ist klar


----------



## messi (21. Jul 2005)

hugo hat gesagt.:
			
		

> So habe jetzt eine Lösung zu dem Problem:
> 
> ```
> int Eins = (int)(Header[3] & 0xFF) * 16777216;
> ...




```
int Serie = (int)Header[3];
Serie <<= 8;
Serie |= (int)Header[2] & 0xFF;
Serie <<= 8;
Serie |= (int)Header[1] & 0xFF;
Serie <<= 8;
Serie |= (int)Header[0] & 0xFF;
```


----------

