for-Schleife mit NumberFormatException

[MisterPhilister]

Hallo

Meine for-Schleife (siehe unten) gibt manchmal eine NumberFromatException aus. Ich habe ein byte[] readBufferwelches ich von der seriellen Schnittstelle füllen lasse. Nun habe ich beim debuggen gesehen, dass da auch negative Werte drin stehen.... und immer dann krieg ich eine NumberFormatException, wieso?

Was ich daraus kriegen will ist ein Integer-Wert als String, aber ich muss mir die Zahl zuerst zusammensetzten aus den Werten die im readBuffer 7-4 stehen. Ich habe gedacht, dass ich die Werte erst in einen HexString wandle, denn was übertragen wird, sollten Hex-Werte sein.

Welchen Fehler mache ich dabei?

for(int i=7; i<=4; i--){//achtung == muss >= sein
            tmpStr = Integer.toHexString(readBuffer[i]);
            strBf.append(tmpStr);
            refStr = strBf.toString();
            value = Integer.parseInt(refStr, 16);
        }
        ref = Integer.toString(value); //Referenznummer als String

 

[kleiner_held]

Der Aufruf Integer.toHexString(readBuffer); wandelt erst den Inhalt von readBuffer in einen int um und gibt diesen hexadizmal aus.
-1 wird zu ffffffff
Wie man sieht arbeitet Integer.toHexString() unsigned.

Integer.parseInt(myString, 16); interpretiert den String aber signed.
Man kann also schon mit Integer.parseInt(Integer.toHexString(-1), 16); die NumberFormatException produzieren.

Wenn ich das richtig verstanden habe, willst du ja eigentlich folgendes:
Du hast 4 byte Werte, die du in einem int wert zusammenfassen willst. Da byte jeweils ein Byte groß ist (welch ein Zufall) und int 4 Byte groß ist, passt das wie die Faust aufs Auge.

Beispiel

byte b[] = new byte[] {1, -2, 3, 4};
int i = 0;
i = i | (b[0] & 255);
i = i << 8;
i = i | (b[1] & 255);
i = i << 8;
i = i | (b[2] & 255);
i = i << 8;
i = i | (b[3] & 255);

Der resultierende int kann natürlich auch negativ sein, wenn deine "Referenznummern" nur positiv sein sollen, musst du long statt int verwenden.

 

[Noctarius]

@kleiner_held:
Vielleicht solltest du Ihr noch kurz erklären was du da eigentlich machst (shiffting). Das kennt nicht Jeder, bzw nicht Jeder hat ganz verstanden, was es eigentlich macht.

 

[MisterPhilister]

@kleiner_held

Sorry, aber für mich ist das auch irgendwie zu hoch, was du da geschrieben hast. Kannst du deinen Code noch etwas ausdeutschen? Da wird ja i immer wieder überschrieben.... kapier ich nicht.

Ja, ich sollte nur positive Werte bekommen.

 

[Noctarius]

Genau das meine ich ^^

Nein die Variable wird nicht überschrieben, sondern der aktuell in der Variable vorhandene Bitwert wird um 8 Bit nach links geshifftet (<< 8), das bedeutet wie in einem Kreis aus 32 Schritten (4Byte * 8 Bit = 32 Bitstellen) bewegst du dich 8 Schritte nach links.

Dann wird der akutelle Wert mit einem negierten Byte in einer Oder-Verknüpfung berechnet und wieder zugewiesen. Dies machst du viermal und hast jedem der 4 Byte eines Integers einen Bytewert zugeordnet.

Um dies besser zu verstehen solltest du am besten mal über Shiffting nachlesen (z.B. hier http://www.janeg.ca/scjp/oper/shift.html) dass sollte das Verständnis des Codes einfacher machen.

Noci

 

[MisterPhilister]

d.h. dann wohl auch, dass ich vorher wissen muss, ob das byte, aus dem ich gerade lese, negativ ist oder nicht? Ich weiss das aber nicht im vornherein...

 

[Noctarius]

Ein Byte ist niemals negativ Ein Byte = 8 Bit = 255 Zustände (welche alle im positiven Bereich liegen)

 

[HoaX]

ein java-byte kann sehr wohl negativ sein, da es signed ist. ein "unsigned byte" gibt es da nicht.

 

[Noctarius]

Hm Tatsache (habs grad nachgeschaut), ok ich nehm es zurück, in Java is nen Byte -128 <-> 127 als Wertebereich.

Hast auch vollkommen recht, gibt ja keine Unsigned Variablen in Java

 

[Marco13]

... außer char.... :roll:

 

[MisterPhilister]

und wie löse ich jetzt mein Problem???

 

[Marco13]

Nu kannst den code, den kleiner_held gepostet hat, auf 4 bytes anwenden, die du aus deinem readBuffer liest.

 

[MisterPhilister]

Einfacher gesagt als getan...

 

[Marco13]

byte b[] = new byte[4];
b[3] = readBuffer[7];
b[2] = readBuffer[6];
b[1] = readBuffer[5];
b[0] = readBuffer[4];
...
der Rest wie bei kleiner_held. Evtl. auch 0...3 statt 3...0 - ich bin gerade auch zu faul, nachzudenken.....

 

[kleiner_held]

OK die Frage mit dem Shiften hat sich ja schon geklärt.

Das Problem mit den negativen Werten wird durch die binäre & Verknüpfung gelöst,
z.B. Zeile 3:

i = i | (b[0] & 255)

Da der Ausdruck links vom = ein int ist, wird der byte Wert b[0] in dieser verwendung automatisch zum int Wert gecastet. Das bedeutet das byte (8 bit) wird auf 32 bit erweitert und dabei werden nicht einfach 24 Nullen vorangestellt, sondern die zusätzlichen 28 Stellen bekommen als Wert den Zustand des ersten Bits vom orginal-byte.

Beispiel:

byte b = 7;      //                            00000111
int i = (int) b; // 00000000 00000000 00000000 00000111
byte c = -128;   //                            10000000
int j = (int) c; // 11111111 11111111 11111111 10000000

Deswegen wird dieser int Wert logisch per & mit int 255 (24 Nullstellen, 8 Einserstellen) verknüpft was bedeutet das im Anschluss die ersten 24 Stellen immer 0 sind, und die letzten 8 denen des ursprünglichen byte entsprechen.
-1 byte wird also zu 255 int.
Dieser Wert wird dann per | mit dem int i verknüpft. Den Ablauf kann man also so beschreiben:

1. leeren int i anlegen, leer heisst alle Bits sind 0
2. die Bits eins byte Wertes an die Stellen 24 - 31 des int kopieren.
3. Inhalt des int per << um 8 Stellen nach links verschieben
... die Schritte 2 & 3 wiederholen bis alle 4 byte werte kopiert wurden.

Als Beispiel vielleicht nochmal folgendes:
Wenn alle 4 byte Wert -1 sind (jeweils 8 Einer-Bits) muss auch der int wert am ende -1 sein (32 Einer-Bits).
Der Wert des int würde sich dann so ändern:

1. 00000000 00000000 00000000 00000000 // initialisiert: int i = 0;
2. 00000000 00000000 00000000 11111111 // 8 bits kopiert per: i = i | (b[0] & 255)
3. 00000000 00000000 11111111 00000000 // umj 8 Stellen nach links verschoben per: i = i << 8; 
4. 00000000 00000000 11111111 11111111 // 8 bits kopiert per: i = i | (b[1] & 255)
5. 00000000 11111111 11111111 00000000 // umj 8 Stellen nach links verschoben per: i = i << 8; 
6. 00000000 11111111 11111111 11111111 // 8 bits kopiert per: i = i | (b[2] & 255)
7. 11111111 11111111 11111111 00000000 // umj 8 Stellen nach links verschoben per: i = i << 8; 
8. 11111111 11111111 11111111 11111111 // 8 bits kopiert per: i = i | (b[3] & 255)

 

[Noctarius]

@ kleiner_held: sehr schön erklärt, alle achtung