# String in Byte Array wandeln



## Herr der Runden (5. Jul 2006)

Hallo, 
ich möchte einen String von variabler Länge in ein byte array kopieren,
nun habe ich mir die methode String.getBytes() zu nutze gamcht und meine
methode war nur noch ein einzeiler:


```
public static byte[] string2Bytes(String s){
           return s.getBytes();
}
```

das liefert mir ein byte array zurück in dem pro zeichen (Bchstabe) ein Byte verwendet wird.
aber java verwendet doch unicode, also 16 bit pro zeichen keine 8, das hat zur folge, dass ich z.b.
das Euro Zeichen (€) nicht zurückbekomme, bei meiner methode in die andere Richtung lese ich aus 
je 2 bytes ein Zeichen aus und daher funktioniert es auch.


```
public static String bytes2String(byte[] b, int offset, int charAnz){
	
	        char[] charBuffer = new char[charAnz];
	
		       for (int i = offset; i <= offset + (charAnz-1)*2; i+=2)
                       {
		       charBuffer[(i-offset)/2] = ByteArray.bytes2Char(b, i);
		        }
		       return new String(charBuffer);
	
        }
                  
         

	public static char bytes2Char(byte[] b, int offset){
		
		return (char)(bytes2Short(b, offset));
	}

	

        public static short bytes2Short (byte[] b, int offset){
		
		return (short)((b[offset] & 0xff)|((b[offset+1] & 0xff)<<8));
	}
```

Wie bekomme ich Unicode aus einem String?


----------



## meez (5. Jul 2006)

Warum übergibst du den byte Array nicht wieder dem String Konstruktor?


----------



## Herr der Runden (5. Jul 2006)

meez hat gesagt.:
			
		

> Warum übergibst du den byte Array nicht wieder dem String Konstruktor?


dann würde doch aus jedem Byte des Arrays ein Zeichen gemacht werden? Oder versteh ich was falsch??  :bahnhof: könntest du kurz in Code posten was du meinst ? danke


----------



## Leroy42 (5. Jul 2006)

Der String wird in ein Byte-Array des Default-Charsets konvertiert.

API:getBytes()

Hier ist auch der Hinweis auf die Klasse CharsetEncoder die das liefert, was du suchst.


----------



## meez (5. Jul 2006)

String s = new String(<byte array>);

Die getBytes() Methode wie auch der Konstruktor sind übrigens vom Encoding abhängig...


----------



## Beni (5. Jul 2006)

```
public static String bytes2String(byte[] b, int offset, int charAnz){
  return new String( b, offset, charAnz );
}
```

Nein, das ist keine 1:1 Umwandlung. Schau dir mal den Code vom String-Konstruktor an, da wird ein spezielles Format benutzt.


----------



## meez (5. Jul 2006)

So...nun sollte es gehen...Jetzt haben 3 verschiedene Leute 3 mal das gleiche gesagt... :wink:


----------



## Herr der Runden (5. Jul 2006)

nöööööö so geht das nit;
die blöde getBytes methode gibt mir pro zeichen des strings nur EIN Byte zurück
aber Strings bestehen aus Char's also ein Zeichen im String -> ein Char

ein Char besteht aber aus 16 Bit ein Byte nur aus 8. soweit verstanden??

die getBytes methode loscht also jewils die ersten 8 bits was manchmal auch nicht weiter auffällt weil
die meisen zeichen in den ersten 8 bits des Char kodiert sind, und die meisen belegungen mit den 2. 8 bits != 0 sind eh undefiniert und daher interessiert das nicht sonderlich, aber beim € sind die letzten 8 bit !=0 und wenn ich jetz den string
"€" mit getBytes umwandel und ihn mit meiner methode zurück zu einem string bau kommt müll dabei raus

"A" = "A"getBytes
"A" = 00000000 01000001
"A"getBytes = 01000001

"€" !=  "€"getBytes
"€" = 00100000 10101100
"€"getBytes = 10101100

 ???:L verstanden?

aber falls es jemanden interessiert, so funktionierts:


```
public static byte[] string2Bytes(String s) {
	char[] cb = new char[s.length()];
	
	s.getChars(0, s.length(), cb, 0);
	byte[] b = new byte[cb.length*2];
	byte[] bBuff = new byte[2];
	
	for (int i = 0; i <= (cb.length-1)*2; i+=2){
		bBuff = ByteArray.Char2Bytes(cb[i/2]);
		b[i]=bBuff[0];
		b[i+1]=bBuff[1];
	}
	return b;
}
```


----------



## Roar (5. Jul 2006)

lies doch einfach mal die dokumentation...


> ncodes this String into a sequence of bytes *using the platform's default charset*, storing the result into a new byte array.



nimm stattdessen getBytes(String)


----------



## Herr der Runden (5. Jul 2006)

hab ich das nicht?

zur doku: ich kann kein englisch


----------



## Roar (5. Jul 2006)

ömm, nö, sonst hättst du ja gar kein problem gehabbt :lol:



> ```
> public static byte[] string2Bytes(String s){
> return s.getBytes();
> }
> ```


----------



## Herr der Runden (5. Jul 2006)

"A" = "A"getBytes
"A" = 00000000 01000001
"A"getBytes = 01000001

"€" != "€"getBytes
"€" = 00100000 10101100
"€"getBytes = 10101100

es geht wirklich nicht! :noe:


----------



## Roar (5. Jul 2006)

!?
getBytes(*String*) :!:


----------



## Herr der Runden (5. Jul 2006)

un wo gibts die methode?
könntest du vielleicht eine zeile quellcode posten? :wink: 

(entweder ich hab recht oder ich steh auffem schlauch?)


----------



## Roar (5. Jul 2006)

Herr der Runden hat gesagt.:
			
		

> un wo gibts die methode?


 in java.lang.String? :lol: :autsch:

du benutzt: "uschabuscha".getBytes()
du sollst benutzen: "uschabuscha".getBytes(hierEinString) :!:
hierEinString ist das encoding, in welchem du deine bytes haben willst.


----------



## Herr der Runden (5. Jul 2006)

ahso "uschabuscha" sag das doch gleich  :bae:  :wink:


----------



## Roar (5. Jul 2006)

Herr der Runden hat gesagt.:
			
		

> ahso "uschabuscha" sag das doch gleich  :bae:  :wink:


???:L


----------



## Herr der Runden (5. Jul 2006)

was ist eigentlich ein encoding?


----------



## lin (5. Jul 2006)

http://en.wikipedia.org/wiki/Character_encoding

handelt sich ja hierbei um n charset
http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html


----------



## Roar (5. Jul 2006)

Herr der Runden hat gesagt.:
			
		

> was ist eigentlich ein encoding?


die ursache deines problems: http://en.wikipedia.org/wiki/Character_encoding

edit: sau  :O :x    :lol:


----------



## Herr der Runden (5. Jul 2006)

[schild=8 fontcolor=000000 shadowcolor=C0C0C0 shieldshadow=1]ich kann kein englisch[/schild] aber ich such ma moin weiter vielleicht find ich was auf deutsch, so ich mach jetz feierabend


----------



## Herr der Runden (6. Jul 2006)

ist es richtig, dass ich bei String.getBytes(*encoding*), für das *encoding* angeben muss in welcher codierung ich das Byte-Array haben will das rauskommt, also bittechnisch was vollkommenes anderes herauskommen kann als reinkommt. Hauptsache das Ergebnis ist in beiden Codierungen das selbe

"A".getBytes(encoding1) = '01101010'bin
"A".getBytes(encoding2) = '00011101'bin

Richtig soweit?

Jetzt hab ich das mal ausprobiert, nur weiß ich nicht so genau was ich jetzt als *encoding* hinschreiben soll, gibts da ne tabelle oder sowas?

Habs schon folgendermaßen ausprobiert: 

```
String s = "Hallo";
s.getBytes("8859_1");
```
_
Unhandled exception type UnsupportedEncodingException
_
wie geht sowas richtig??  :bahnhof:  
Also ich glaube ich such ne Tabelle in der steht was ich an die Stelle *encoding* schreiben kann. Oder bin ich auffem Holzweg?


----------



## Murray (6. Jul 2006)

Sieh Dir mal java.nio.charset.Charset an; ist zwar auch Englisch, aber die Tabelle versteht man auch so.



			
				Javadoc hat gesagt.:
			
		

> Standard charsets
> 
> Every implementation of the Java platform is required to support the following standard charsets. Consult the release documentation for your implementation to see if any other charsets are supported. The behavior of such optional charsets may differ between implementations.
> 
> ...


----------



## Herr der Runden (6. Jul 2006)

ok ich gebs auf:


```
s.getBytes("UTF-8");
```

da bekomm ich die gleiche Fehlermeldung wie oben

 :?


----------



## lin (6. Jul 2006)

Sollte eigentlich klappen ^^. 


```
String s = "Hallo";
s.getBytes("UTF-8");    
s.getBytes("US-ASCII");
s.getBytes("ISO-8859-1");
s.getBytes("UTF-16");
```


----------



## Herr der Runden (6. Jul 2006)

ok, dann mal vielen Dank für die Hilfe, und auch für die Hilfe zur Selbsthilfe, dann poste ich hier mal das Ergebnis, für verbesserungsvorschläge bin ich jederzeit froh, ist aber in erster linie als ergebnis gedacht:


```
/**  Die Klasse 'Byte Array' beinhaltet Methoden zur umwandlung eines Byte-Array's in
 * verschiedene Datentypen und die jeweils umgekehrte Methode dieser Datentypen in
 * ein Byte-Array 
 * Alle Methoden wandeln um indem sie die Daten Bitweise Verschieben, es werden weder
 * Vorzeichen noch andere Notationen beachtet 
 * @author xxxxxxxx
 * 
 */
public class ByteArray {
	
	/** Die Methode <code>chkSize</code> prüft ein <code>byte[]</code>  auf existenz und ausreichende Größe
	 * um auch wirklich einen bestimmten Datentyp ermitteln zu können.
	 *  
	 * @param b das Byte-Array welches auf existens und Größe geprüft werden soll
	 * @param offset Startpunkt im Byte-Array
	 * @param size Länge die ab dem startpunkt existieren muss
	 * @return 'true' wenn die existens besteht und die Größe ausreicht, false wenn dies nicht zutrifft
	 * @throws IllegalArgumentException wenn das array nicht existiert oder es zu klein ist
	 */
	private static boolean chkSize(byte[] b, int offset, int size)throws IllegalArgumentException{
		
		if (b != null && b.length >= offset + size){return true;}
		else throw new IllegalArgumentException(" array zu klein ");	
	}
	
	
	/** 
	 * Die Methode <code>bytes2Short</code> wandelt ein <code>byte[]</code> in einen <code>short</code> 
	 * um. Die Ergebnisvariable setzt sich aus den 2 Bytes 'b[offset]' und b[offset + 1]
	 * zusammen. 
	 * Beide Bytes werden als vorzeichenlos betrachtet und einfach hintereinander gesetzt.
	 * <code>b[offset]</code> ist niederwertig und <code>b[offset+1]</code> höherwertig. Das Vorzeichenbit von
	 * <code>b[offset+1]</code> wird auch in der neuen Variablen Short zum Vorzeichenbit.
	 *  
	 * @param b Quell Byte-Array 
	 * @param offset Stelle im Array an der angefangen wird umzuwandeln
	 * @return gibt <code>short</code> zurück der aus dem Byte Array erstellt wurde
	 */
	public static short bytes2Short (byte[] b, int offset){
		
		if (chkSize(b, offset, 2) == true){
			return (short)((b[offset] & 0xff)|((b[offset+1] & 0xff)<<8));
		}
	return 0;
	}
	
	
	/** Die Methode <code>bytes2Int</code> basiert auf der Methode <code>bytes2Short</code>, 
	 * mit dem Unterschied, dass 2 Variablen vom Typ <code>short</code> bitweise 
	 * in einen <code>int</code> geschoben werden. Das Quellarray muss 
	 * mindestens <code>offset+4</code> Elemente besitzen
	 *  
	 * @param b Quell Byte-Array
	 * @param offset Stelle im Array an der angefangen wird umzuwandeln
	 * @return gibt <code>int</code> zurück der aus dem <code>byte[]</code> erstellt wurde
	 */
	public static int bytes2Int(byte[] b, int offset){
		
		if (chkSize(b, offset, 4)){
			return ((bytes2Short(b, offset)&0xffff)|((bytes2Short(b, offset + 2)&0xffff)<<16));
		}
		return 0;
	}
	
	
	/** Die Methode <code>bytes2Long</code> basiert wie die Methode <code>bytes2Int</code> auf dem 
	 * Prinzip der Methode <code>bytes2Short</code> nur das hier 2 Variablen vom Typ <code>int</code> 
	 * zusammengeschoben werden und sich die mindestgröße des Quallarrays somit
	 * auf offset+8 beläuft. 
	 * 
	 * @param b Quell Byte-Array
	 * @param offset Stelle im Array an der angefangen wird umzuwandeln
	 * @return gibt <code>long</code> zurück der aus dem <code>byte[]</code> erstellt wurde
	 */
	public static long bytes2Long(byte[] b, int offset){
		
		if (chkSize(b, offset, 8)){
		
			return ((long)(bytes2Int(b, offset)&0xffffffff)|((long)(bytes2Int(b, offset + 4)&0xffffffff)<<32));
		}
		return 0;
	}
	
	
	/** Die Methode <code>bytes2Float</code> wandelt ein <code>byte[]</code> in eine Variable des Typ's 
	 * <code>float</code> um. Dazu wird zuerst die Methode <code>bytes2Int</code> aufgerufen. Dieses 
	 * Ergebnis wird anschließend Bitweise in einen <code>float</code> geschrieben und 
	 * zuzrückgegeben
	 * 
	 * @param b Quell Byte-Array
	 * @param offset Stelle im Array an der angefangen wird umzuwandeln
	 * @return gibt <code>float</code> zurück der aus dem <code>byte[]</code> erstellt wurde
	 */
	public static float bytes2Float(byte[] b, int offset){
		
		return Float.intBitsToFloat(bytes2Int(b, offset));	
		}
	
	
	/** Die Methode 'bytes2Double' basiert auf der Methode 'bytes2Float' nur das sie
	 * logischerweise auf die Methode 'bytes2Long' zurückgreift. 
	 * 
	 * @param b Quell Byte-Array
	 * @param offset Stelle im Array an der angefangen wird umzuwandeln
	 * @return gibt <code>double</code> zurück der aus dem <code>byte[]</code> erstellt wurde
	 */
	public static double bytes2Double(byte[] b, int offset){
		
		return Double.longBitsToDouble(bytes2Long(b, offset));	
		}
	
	
	/** Die Methode <code>bytes2Char</code> macht aus 2 Bytes des Byte-Arrays <code>'b'</code> ein <code>char</code> und 
	 * nutzt hierzu die Methode <code>bytes2Short</code>.
	 *  
	 * @param b Quell Byte-Array
	 * @param offset Stelle im Array an der angefangen wird umzuwandeln
	 * @return gibt <code>char</code> zurück der aus dem <code>byte[]</code> erstellt wurde
	 */
	public static char bytes2Char(byte[] b, int offset){
		
		return (char)(bytes2Short(b, offset));
	}
	
	
	/** Die Methode 'bytes2PascalString' gibt einen String zurück, bei dem aber das array in
	 * einer bestimmten Form betrachtet wird:
	 * b[offset] - gibt die länge des strings an 0-255 
	 * jedes weitere Byte wird nun als ein Zeichen betrachtet.
	 * 
	 * @param b Quell Byte-Array
	 * @param offset Stelle im Array an der angefangen wird umzuwandeln
	 * @return gibt <code>String</code> zurück der aus dem <code>byte[]</code> erstellt wurde
	 */
	public static String bytes2PascalString(byte[] b, int offset){
	    
		if (chkSize(b, offset, (short)b[offset]&0xff)==true){
	    	byte[] erg = new byte[(short)b[offset]&0xff];
	    	System.arraycopy(b, offset + 1, erg, 0, (short)b[offset]&0xff);
	    	return new String(erg);
	    }
	    return "";
	}
	
	
	/** Die Methode 'bytes2String' wandelt ein Byte-Array in einen String um, indem 
	 * für jedes Zeichen 2 Bytes zu einem Unicode-Zeichen umgewandelt werden.
	 * 'charAnz' gibt an wie viele Zeichen der entstehende String enthalten soll
	 * Daher Achtung die minimale Größe des ByteArray's 'b' berechnet sich 
	 * durch: offset + (2 * charAnz)
	 * 
	 * @param b Quell Byte-Array
	 * @param offset Stelle im Array an der angefangen wird umzuwandeln
	 * @param charAnz Anzahl der dargestellten Zeichen im zurückgegebenen String
	 * @return gibt <code>String</code> zurück der aus dem <code>byte[]</code> erstellt wurde
	 */
	public static String bytes2String(byte[] b, int offset, int charAnz){
		
		char[] charBuffer = new char[charAnz];

		if (ByteArray.chkSize(b, offset, charAnz * 2) == true){
			
			for (int i = offset; i <= offset + (charAnz-1)*2; i+=2){
			charBuffer[(i-offset)/2] = bytes2Char(b, i);
			}
			return new String(charBuffer);
		}
		else return "";
	}
	
	/** Die Methode <code>short2Bytes</code> ist das Gegenstück zur Methode <code>bytes2Short</code>, sie schreibt
	 * die ersten 8 Bit in ein <code>byte</code> und dann die letzten 8 in ein anderes. Diese werden dann
	 * in Form eines Array zurückgegeben. 
	 * 
	 * @param n die Variable die in ein Byte Array geschrieben werden soll
	 * @return gibt <code>byte[]</code> zurück in dem bitweise <code>n</code> steht
	 */
	public static byte[] short2Bytes(short n){
		
		byte[] b = new byte[2];
		b[0] = (byte)(n);
		b[1] = (byte)(n>>>8);
		return b;
	}
	
	/** Die Methode gibt <code>int2Bytes</code> ist das gegenstück zur Methode <code>bytes2Int</code> und basiert auf dem 
	 * System der Methode <code>short2Bytes</code> und wandelt ein <code>int</code> in ein <code>byte[]</code> mit 4 Elementen um. 
	 * 
	 * @param n die Variable die in ein Byte Array geschrieben werden soll
	 * @return gibt <code>byte[]</code> zurück in dem bitweise <code>n</code> steht
	 */
	public static byte[] int2Bytes(int n){
		
		byte[] b = new byte[4];
		for (int i = 0; i <= 3; i++){
			b[i] =(byte)(n>>>i*8);
		}
		return b;
	}

	/** Die Methode <code>long2Bytes</code> ist das gegenstück zur Methode <code>bytes2Long</code> und basiert auf dem 
	 * System der Methode <code>short2Bytes</code> und wandelt ein <code>long</code> in ein </code>byte[]</code> mit 8 Elementen um.
	 *  
	 * @param n die Variable die in ein Byte Array geschrieben werden soll
	 * @return gibt <code>byte[]</code> zurück in dem bitweise <code>n</code> steht
	 */
	public static byte[] long2Bytes(long n){
		
		byte[] b = new byte[8];
		for (int i = 0; i <= 7; i++){
			b[i] =(byte)(n>>>i*8);
		}
		return b;
	}

	/** Die Methode <code>float2Bytes</code> ist das Gegenstück zur Methode <code>bytes2Float</code>
	 * und bedient sich dazu der Methode <code>int2Bytes</code>
	 *
	 * @param n die Variable die in ein Byte Array geschrieben werden soll
	 * @return gibt <code>byte[]</code> zurück in dem bitweise <code>n</code> steht
	 */
	public static byte[] float2Bytes(float n){
		
		return int2Bytes(Float.floatToIntBits(n));
	}
	
	/** Die Methode gibt <code>double2Bytes</code> ist das Gegenstück zur Methode <code>bytes2Double</code>
	 * und bedient sich dazu der Methode <code>long2Bytes</code> 	
	 *
	 * @param n die Variable die in ein Byte Array geschrieben werden soll
	 * @return gibt <code>byte[]</code> zurück in dem bitweise <code>n</code> steht
	 */
	public static byte[] double2Bytes(double n){
		
		return long2Bytes(Double.doubleToLongBits(n));
	}
	
	/** Die Methode <code>char2Bytes</code> wandelt ein <code>char</code> in ein <code>byte[]</code> mit 2 Elementen um 
	 * und ist das Gegenstück zu <code>bytes2Char</code>
	 * 	
	 * @param c die Variable die in ein Byte Array geschrieben werden soll
	 * @return gibt <code>byte[]</code> zurück in dem bitweise <code>c</code> steht
	 */
	public static byte[] char2Bytes(char c){
		
		return (short2Bytes((short)c));
		
	}
		
	
	/**Die Methode <code>string2Bytes</code> wandelt einen <code>String</code> in ein <code>byte[]</code> mit 
	 * (Anzahl der Zeichen im String) * 2 Elementen. Sie ist das Gegenstück
	 * zu <code>bytes2String</code> 
	 * 
	 * @param s die Variable die in ein Byte Array geschrieben werden soll
	 * @return gibt <code>byte[]</code> zurück in dem bitweise <code>s</code> steht
	 */
	public static byte[] string2Bytes(String s) {
		char[] cb = new char[s.length()];
		
		s.getChars(0, s.length(), cb, 0);
		byte[] b = new byte[cb.length*2];
		byte[] bBuff = new byte[2];
		
		for (int i = 0; i <= (cb.length-1)*2; i+=2){
			bBuff = char2Bytes(cb[i/2]);
			b[i]=bBuff[0];
			b[i+1]=bBuff[1];
		}
		return b;
	}
	

	/**Die Methode <code>string2PasStrInBytes</code> wandelt einen <code>String</code> in ein <code>byte[]</code> um, bei dem
	 * allerdings für ein Zeichen nur ein <code>byte</code> verwendet wird, und außerdem noch ein
	 * <code>byte</code> mit der Länge des <code>Strings</code> vorangestellt wird daraus ergibt sich die Anzahl
	 * der Elemente im <code>byte[]</code> (Anzahl der Zeichen im String) + 1.
	 * Diese Methode ist das Gegenstück zu <code>bytes2PascalString.</code>
	 * 
	 * @param s die Variable die in ein Byte Array geschrieben werden soll
	 * @return gibt <code>byte[]</code> zurück in dem Pascal codiert <code>s</code> steht
	 */
	public static byte[] string2PasStrInBytes(String s){
		
		byte[] erg = new byte[s.getBytes().length + 1];
		System.arraycopy(s.getBytes(), 0, erg, 1, s.getBytes().length);
		erg[0] = (byte)s.length();
		return erg;
	}
		
}
```
so das is jetzt alles


----------

