Java Byte Array to Float

[Squicky]

Hallo

Ein Netzwerkstream schreibt vier Bytes in ein Byte Array (ba[0] ... ba [3]).
Dabei handelt es sich um eine Float Zahl.

Wie kann man aus diesen vier Bytes eine Float erhalten?

Danke

 

[yoT!mO]

nimm ba[0], steck es in eine float-Variable, schieb es dort um 3*8 nach links
nimm ba[1], steck es in die selbe Variable, schieb es dort um 2*8 nach links.
usw.

Edit: Ok, ganz eindeutig war das jetzt nicht. So müsste es besser gehen:

float f  = 0;
for (int i = 0; i < 3; i++) {
    f = f | ba[i];
    f = f << 8;
}
f = f | ba[3]

müsste so stimmen.

Gruß Timo

 

[Squicky]

leider gibt es eien Fehler:

error: bad operand types for binary operator '|'
                    f = f | ba[i];
  first type:  float
  second type: byte

 

[yoT!mO]

Dann caste doch dein Byte nach float, bevor du es mit f verODERst.

Gruß Timo

 

[Squicky]

schon getestet:

float f = 0;
float a = 0;
 for (int i = 0; i < 4; i++) {
    a = ba[i];
    f = f | a;
    f = f << 8;
}

-->

error: bad operand types for binary operator '|'
                    f = f | a;
  first type:  float
  second type: float

 

[yoT!mO]

Ok ich seh grad, das ist doch schwerer als gedacht^^

 

[Whiz-zarD]

Das liegt daran, dass float eine Fließkommazahl ist. Die werden anders abgebildet, als ganzzahlige Typen.
Bitoperatoren kann man nur bei ganzzahligen Typen verwenden.

Wie wird denn überhaupt die Fließkommazahl in ein Array zerlegt?

 

[yoT!mO]

Ist es denn in Java nicht möglich, auch bei Fließkommazahlen bit-weise zu operieren?
Bzw. gibt es denn eine Möglichkeit, die Bits einer kleinen Fließkommzahl in die LSBs einer großen Fließkommzahl zu schieben?

Gruß Timo

 

[Whiz-zarD]

Es ist in keiner mir bekannter Sprache möglich, Bitoperatoren auf Fließkommazahlen durchzuführen.
Sowas ist einfach nicht vorgesehen.
Wie gesagt, Fließkommazahlen werden anders abgebildet.
Eine Fließkommazahl besteht aus einem Vorzeichen-Bit, einigen Mantissen-Bits und einigen Exponenten-Bits.

http://de.wikipedia.org/wiki/IEEE_754

 

[ice-breaker]

Du kannst die Bytes erst in einen Integer umwandeln (um somit eine 32Bit Bitkette zu haben) und dann mit Float.intBitsToFloat() in eine Float-Zahl "umwandeln".
Dabei wird die Zahl nicht in echt umgewandelt sondern einfach die Bit-Kette in den Float-Speicherplatz kopiert.
Es ist also eigentlich mehr eine Funktion um eine Float-Zahl anhand einer Bit-Kette aufzubauen.

 

[antred]

Es ist in keiner mir bekannter Sprache möglich, Bitoperatoren auf Fließkommazahlen durchzuführen.

Na ja, zumindest nicht ohne dreckige Tricksereien.

 

[yoT!mO]

Ja, ich weiß, wie Fließkommazahlen im Rechner dargestellt werden.
Aber im Grunde ist auch ein float nichts anderes als eine Folge von 32 Bits. Und ich versteh nicht, wieso man auf diese Bits keine Operationen anwenden darf/soll. O_o
Wie die Bits nachher interpretiert werden sollen, kann doch der Bit-Operation egal sein, oder?

Gruß Timo

 

[Killkrog]

Das ist eigentlich ziemlich einfach zu lösen...

public static void main(String[] args) throws Throwable {
	// Folgende Bytes ergeben aneinander gereiht die Zahl 13.37 nach IEEE-754
	byte[] bytesReceived = new byte[4];
	bytesReceived[0] = (byte) 0x00000041;
	bytesReceived[1] = (byte) 0x00000055;
	bytesReceived[2] = (byte) 0x000000eb;
	bytesReceived[3] = (byte) 0x00000085;

	final int BYTE_BIT_MASK = 0x000000ff;
	int rawInteger = 0;
	for (byte receivedByte : bytesReceived) {
		rawInteger <<= 8;
		rawInteger |= (receivedByte & BYTE_BIT_MASK);
	}
	System.out.println(Float.intBitsToFloat(rawInteger)); // => Müsste wieder 13.37 ergeben
}

 

[dasTTS]

	public static void main(String[] args) {
		
		byte[] bytesReceived = new byte[4];
		bytesReceived[0] = (byte) 0x00000041;
		bytesReceived[1] = (byte) 0x00000055;
		bytesReceived[2] = (byte) 0x000000eb;
		bytesReceived[3] = (byte) 0x00000085;
		
		ByteBuffer b = ByteBuffer.wrap(bytesReceived);
		System.out.println(b.getFloat());
	}

 

[Killkrog]

Der ByteBuffer definiert Overhead ganz neu

 

[dasTTS]

Da hast du definitiv Recht , deine Methode wird sehr viel Zeit sparen. Aber da ich das konstrukt des ByteBuffers prima finde, habe ich die Lösung gepostet.

 

[Killkrog]

Oh, mir ist gerade noch was eingefallen. Die ByteBitMask wirste eventuell nicht brauchen in deinem Anwendungsfall. Das ist bei mir nur drin weil Java die Highs bei negativen Bytes mit Einsen füllt...