# Alle Datentypen in byte Array und zurückwandeln



## Snooky (30. Jun 2009)

Hallo Leute,

ich habe folgendes Problem:
Ich nutze eine Schnittstelle, um mit einer Komponente zu kommunizieren, die fürs Schreiben in ihre Offsets nur byte Arrays zulässt.
Also möchte ich gerne alle Datentypen, die Java mir so bietet (short, int, long, float, double, String brauche ich vorerst nicht), in byte Arrays schreiben.
Dazu habe ich mir folgendes Programm geschrieben:


```
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;


public class byteFacility {
	
	private ByteArrayOutputStream bytestream = new ByteArrayOutputStream();
	private DataOutputStream datastream = new DataOutputStream(bytestream);
	
	public byte[] toByte(short value) throws IOException
	{		
			datastream.writeShort(value);
			datastream.flush();
			byte[] bytes = bytestream.toByteArray();
			bytestream.flush();
			return bytes;
			
			
	}
	
	
	public byte[] toByte(int value) throws IOException
	{		
			
			datastream.writeInt(value);
			datastream.flush();
			byte[] bytes = bytestream.toByteArray();		
			return bytes;
	}

	
	public byte[] toByte(long value) throws IOException
	{		
			datastream.writeLong(value);
			datastream.flush();
			byte[] bytes = bytestream.toByteArray();		
			return bytes;
			
	}

	
	public byte[] toByte(float value) throws IOException
	{		
			datastream.writeFloat(value);
			datastream.flush();
			byte[] bytes = bytestream.toByteArray();		
			return bytes;
	}
	
	public byte[] toByte(double value) throws IOException
	{		
			datastream.writeDouble(value);
			datastream.flush();
			byte[] bytes = bytestream.toByteArray();		
			return bytes;
	}



}
```

Nun lasse ich mir in einem Testprogramm alle Variablen zur Probe einmal umrechen:


```
byteFacility bf = new byteFacility();
		short a = 27;
		int b = 573;
		long c = 123878;
		float d = 0.5678F;
		double e = 0.12345;
		
		byte[] ab = bf.toByte(a);
		byte[] bb = bf.toByte(b);
		byte[] cb = bf.toByte(c);
		byte[] db = bf.toByte(d);
		byte[] eb = bf.toByte(e);
```

Jetzt macht mich erstmal folgendes stutzig:
Wenn ich mir über .length die Länge der byteArrays ausgeben lasse, bekomme ich folgende Ausgabe (von ab .. eb):
2
6
14
18
26

Ich dachte eigentlich, Int in Byte wären immer 4, long immer 8, float ebenfalls 4, und double auch 4. Was ist da passiert?

Das Zurückwandeln funktioniert auch nicht, dort bekomme ich Fehlermeldungen oder 6192.
Das Zurückwandeln ist allerdings auch nicht wichtig, ich wollte hier eher überprüfen, ob mein Umwandeln in byteArrays funktioniert.
Da ich das Zurückwandeln aber 1:1 aus der Komponente, mit der ich sprechen will, geklaut habe, macht mich das doch etwas stutzig.
Sind meine Arrays kaputt oder funktioniert die Komponente etwa nicht richtig?

Zum Schluss nochmal der Code, mit dem ich zurückwandle:


```
ByteArrayOutputStream bytestream = new ByteArrayOutputStream();
			DataOutputStream datastream = new DataOutputStream(bytestream);
					
			
			ByteBuffer buf = ByteBuffer.allocate(2);
			buf.order(ByteOrder.LITTLE_ENDIAN);
			buf.put(ab);
			System.out.println(buf.getShort(0));
```
Dieser Code gibt mir nun für meinen Short 6192 aus. Warum tut er das und was muss ich anders machen? 
Ich hänge nochmal den "Original-Code" an, von dem ich geklaut habe, exemplarisch für byte und Short.


```
public byte getByte(int aOffset)
		{
		byte[] data = new byte[1];
		fsuipc_wrapper.ReadData(aOffset,1,data);
		return data[0];
		}
    
	public short getShort(int aOffset)
		{
		ByteBuffer buf = ByteBuffer.allocate(2);
		buf.order(ByteOrder.LITTLE_ENDIAN);
		byte[] data = new byte[2];
		fsuipc_wrapper.ReadData(aOffset,2,data);
		buf.put(data,0,2);
		return buf.getShort(0);
		}
```

Vielen Dank im Voraus für eure Hilfe 
Sascha


----------



## Marco13 (30. Jun 2009)

Äh - du schreibst schon immer in den_selben_ stream!? Berechne mal die Differenzen der ausgegebenen Werte, dann könnt's hinkommen...


----------



## Snooky (30. Jun 2009)

Hey,

ich glaube, ich habs.
Ich hab nun den OutputStream und den ByteArrayOutputStream jeweils in den Methoden definiert und versuche es gleich nochmal als Attribut, wobei ich den ByteArrayOutputStream dann immer als erstes lösche.

Was wäre programmiertechnisch die sauberere Lösung? Als Attribute oder in den Methoden selbst?

Edit: Das Problem lag wohl wirklich in meiner selbst geschriebenen Klasse. Hier wurde der ByteArrayOutputStream wohl mehrfach belegt, was dann zu den seltsamen Zahlenwerten führte.

2. Edit: Ok, nun hab ichs wirklich. Ich habe .flush() für den ByteArrayOutputStream genutzt. Der hat aber nur die Werte gelöscht, nicht die Länge. Somit war mein Integer Array dann auch 6 lang, die vom short, der vorher verarbeitet wurde, +4 vom Integer, der danach dran war.

Danke


----------

