✔ Konvertierung von Integer in Byte Array

[javaprogger1987]

Hallo!
Ich hab folgendes Problem, ich würde gerne Integer als Byte-Arrays (4 Byte) haben,
um die über Sockets zu verschicken.. Mache das im Moment noch so, dass ich die
Integer als Strings übertrage, was ja nicht gerade die beste Lösung ist.
Nun hab ich schon was gefunden nämlich folgendes:

Byte Array -> Int

 arrayInputStream = new ByteArrayInputStream( buf ); //buf = byte[]
 dataInputStream = new DataInputStream( arrayInputStream );
int id = dataInputStream.readInt();

Int -> Byte Array

     private ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream( 0 );
     private DataOutputStream dataOutputStream = new DataOutputStream( arrayOutputStream );
   
   dataOutputStream.writeInt( userId );
   dataOutputStream.flush();
   
   byte[] id = arrayOutputStream.toByteArray();

Das funktioniert auch schon so ganz gut.. Ist halt nur etwas aufwendig, vor allem weil
ich immer wieder neue Streams erzeugen muss.. Gibt es da nicht ne einfachere Methode?
Danke schonmal!

Tobias

 

[RedWing]

Wieso machst du des nicht einfach über nen String?

byte[] data = new byte[10];
int number =Integer.parseInt(new String(data));

und umgekehrt:

byte[] data =String.valueOf(100).getBytes();

Gruß

RedWing

 

[javaprogger1987]

Ja so hatte ich das erst auch, aber dann muss ich noch zusätlich die Länge des Strings mit übertragen (nicht immer 4 Byte) und bei großen Zahlen muss ich da mehr als das doppelte übertragen.. Und es müssen ziemlich viele Daten verschickt werden, deswegen
versuch ich soviel wie möglich einzusparen..

 

[Matthias Reitinger]

Eine Lösung mit Bitoperationen:

int number;
byte[] data = new byte[4];

// int -> byte[]
for (int i = 0; i < 4; ++i) {
	int shift = i << 3; // i * 8
	data[3-i] = (byte)((number & (0xff << shift)) >>> shift);
}

// byte[] -> int
number = 0;		
for (int i = 0; i < 4; ++i) {
	number |= (data[3-i] & 0xff) << (i << 3);
}

 

[javaprogger1987]

Ja danke genauso etwas hab ich gesucht.. Vielen Dank!

 

[Thomas Darimont]

Hallo!

Ich würde einfach folgendes machen:
(Vor allem das Debugging wird dadurch ein wenig einfacher...)

package de.tutorials;
   /**
    * @author Tom
    * 
    */
   public class IntToByteArrayConversionExample {

   	public static void main(String[] args) {
   		int val = Integer.parseInt("00001000" + "00000100" + "00000010"	+ "00000001", 2);
   
   		System.out.println(val);
   
   		byte[] buffer = convertIntToByteArray(val);
   
   		System.out.println(buffer[0]);
   		System.out.println(buffer[1]);
   		System.out.println(buffer[2]);
   		System.out.println(buffer[3]);
   
   		int value = convertByteArrayToInt(buffer);
   		System.out.println(value);
   
   	}
   
   	private static int convertByteArrayToInt(byte[] buffer) {
   		if (buffer.length != 4) {
 			throw new IllegalArgumentException("buffer length must be 4 bytes!");
   		}
   		
 		int 
 		value  = (0xFF & buffer[0]) << 24 ;
 		value |= (0xFF & buffer[1]) << 16;
 		value |= (0xFF & buffer[2]) << 8;
   		value |= (0xFF & buffer[3]);
   		
   		return value;
   	}
   
   	private static byte[] convertIntToByteArray(int val) {
   		byte[] buffer = new byte[4];
   
   		buffer[0] = (byte) (val >>> 24);
   		buffer[1] = (byte) (val >>> 16);
   		buffer[2] = (byte) (val >>> 8);
   		buffer[3] = (byte) val;
   		
   		return buffer;
   	}
   }

Eine weitere Moeglichkeit waere auch folgendes:

 /**
  * 
  */
 package de.tutorials;
 
 import java.nio.ByteBuffer;
 
 public class ByteBufferTest {
 
 	public static void main(String[] args) {
 		int val = Integer.valueOf("00001000" + 
 		    		    		  "00000100" + 
 		    		    		  "00000010" + 
 		    		    		  "00000001", 2);
 
 		System.out.println(val);
 
 		ByteBuffer buffer = ByteBuffer.allocate(4);
 		buffer.putInt(val);
 		byte[] bytes = buffer.array();
 		
 		buffer.clear();
 		
 		buffer.put(bytes);
 		buffer.flip();
 		int value = buffer.getInt();
 
 		System.out.println(value);
 	}
 
 }

//edit: Kleine Fehlerkorrektur durch den Post von deref.

Gruss Tom

 

[ATha1]

Ich weiß ja nicht wie dein Protokoll aussieht, aber warum verwendest nicht weiterhin den DataInput- und DataOutputStream?

Statt dem ByteArrayInputStream schickst du das Ganze gleich übern OutputStream vom Socket?

Wennst ein definiertes Protokoll für die Kommunikation hast, ist das eigentlich eh das einfachste.

 

[javaprogger1987]

Vielen Dank für die vielen Antworten

@Tom Deine Version macht aber im Prinzip das gleiche wie die von Matthias oder? Nur das die noch die Länge der Arrays überprüft? (Der Fehler kann bei mir nicht mehr auftreten, habs so umgeschrieben..)

   public static int byteArrayToInt( byte[] array, int off )
   {
 	byte[] data = new byte[4];
 	System.arraycopy( array, off, data, 0, 4 );
 
 	int number = 0;
 	for (int i = 0; i < 4; ++i)
 	{
 	  number |= (data[3-i] & 0xff) << (i << 3);
 	}
 	return number;
   }

@ATha1 Das ist eigentlich auch ne gute Idee.. Da muss ich mal gucken ob ich das vllt. nicht so mache

 

[Thomas Darimont]

Hallo!

@Tom Deine Version macht aber im Prinzip das gleiche wie die von Matthias oder? Nur das die noch die Länge der Arrays überprüft? (Der Fehler kann bei mir nicht mehr auftreten, habs so umgeschrieben..)

Genau. Welche Version findest du les- bzw. wartbarer und leichter verstaendlich?

Gruss Tom

 

[javaprogger1987]

Naja so viel anders wär ja so auch nicht (Ich brauch das mit dem Offset, dann spar ich mir das umkopieren im Hauptprogramm )

 public static int byteArrayToInt( byte[] array, int off )
{
  byte[] data = new byte[4];
  System.arraycopy( array, off, data, 0, 4 );

  int value = buffer[0] << 24 | buffer[1] << 16 | buffer[2] << 8
    			| buffer[3];
  return value;
}

Ich muss mich sowieso noch mal mit dem Bitzeugs beschäftigen, von wegen left und right shift

Deine
convertIntToByteArray(int val) ist aber auf jeden Fall besser zu verstehen *schleim*