So konvertieren Sie Strings in und von UTF8-Byte-Arrays in Java

In Java habe ich einen String und möchte ihn als Byte-Array codieren (in UTF8 oder einer anderen Codierung). Alternativ habe ich ein Byte-Array (in einer bekannten Codierung) und möchte es in einen Java-String konvertieren. Wie mache ich diese Konvertierungen?

Von String in Byte konvertieren []:

String s = "some text here";
byte[] b = s.getBytes(StandardCharsets.UTF_8);

Von Byte [] in String konvertieren:

byte[] b = {(byte) 99, (byte)97, (byte)116};
String s = new String(b, StandardCharsets.US_ASCII);

Sie sollten natürlich den richtigen Codierungsnamen verwenden. In meinen Beispielen wurden US-ASCII und UTF-8 verwendet, die beiden am häufigsten verwendeten Codierungen.

Hier ist eine Lösung, die es vermeidet, die Zeichensatzsuche für jede Konvertierung durchzuführen:

import java.nio.charset.Charset;

private final Charset UTF8_CHARSET = Charset.forName("UTF-8");

String decodeUTF8(byte[] bytes) {
    return new String(bytes, UTF8_CHARSET);
}

byte[] encodeUTF8(String string) {
    return string.getBytes(UTF8_CHARSET);
}

String original = "hello world";
byte[] utf8Bytes = original.getBytes("UTF-8");

Sie können direkt über den Konstruktor String (byte [], String) und die Methode getBytes (String) konvertieren. Java macht verfügbare Zeichensätze über die Charset- Klasse verfügbar . In der JDK-Dokumentation sind die unterstützten Codierungen aufgeführt .

In 90% der Fälle werden solche Konvertierungen in Streams durchgeführt, sodass Sie die Reader / Writer- Klassen verwenden würden. Sie würden nicht schrittweise mit den String-Methoden für beliebige Byte-Streams dekodieren - Sie würden sich für Fehler mit Multibyte-Zeichen offen lassen.

Meine Tomcat7-Implementierung akzeptiert Zeichenfolgen als ISO-8859-1. trotz des Inhaltstyps der HTTP-Anfrage. Die folgende Lösung hat bei mir funktioniert, als ich versucht habe, Zeichen wie 'é' richtig zu interpretieren.

byte[] b1 = szP1.getBytes("ISO-8859-1");
System.out.println(b1.toString());

String szUT8 = new String(b1, "UTF-8");
System.out.println(szUT8);

Beim Versuch, die Zeichenfolge als US-ASCII zu interpretieren, wurden die Byteinformationen nicht korrekt interpretiert.

b1 = szP1.getBytes("US-ASCII");
System.out.println(b1.toString());

Alternativ können StringUtils von Apache Commons verwendet werden.

 byte[] bytes = {(byte) 1};
 String convertedString = StringUtils.newStringUtf8(bytes);

oder

 String myString = "example";
 byte[] convertedBytes = StringUtils.getBytesUtf8(myString);

Wenn Sie einen nicht standardmäßigen Zeichensatz haben, können Sie getBytesUnchecked () oder newString () entsprechend verwenden.

Zum Dekodieren einer Reihe von Bytes in eine normale Zeichenfolgennachricht habe ich es endlich mit der UTF-8-Codierung mit diesem Code zum Laufen gebracht:

/* Convert a list of UTF-8 numbers to a normal String
 * Usefull for decoding a jms message that is delivered as a sequence of bytes instead of plain text
 */
public String convertUtf8NumbersToString(String[] numbers){
    int length = numbers.length;
    byte[] data = new byte[length];

    for(int i = 0; i< length; i++){
        data[i] = Byte.parseByte(numbers[i]);
    }
    return new String(data, Charset.forName("UTF-8"));
}

Wenn Sie 7-Bit-ASCII oder ISO-8859-1 (ein erstaunlich verbreitetes Format) verwenden, müssen Sie keinen neuen java.lang.String erstellen . Es ist viel viel performanter, das Byte einfach in char umzuwandeln:

Vollständiges Arbeitsbeispiel:

for (byte b : new byte[] { 43, 45, (byte) 215, (byte) 247 }) {
    char c = (char) b;
    System.out.print(c);
}

Wenn Sie nicht mit extended-Zeichen wie Ä, Æ, A, C, I, E und können sicher sein , dass die einzigen übertragenen Werte sind von den ersten 128 Unicode - Zeichen, dann wird dieser Code auch Arbeit für UTF-8 und erweiterten ASCII (wie cp-1252).

Ich kann nicht kommentieren, möchte aber keinen neuen Thread starten. Aber das funktioniert nicht. Eine einfache Rundreise:

byte[] b = new byte[]{ 0, 0, 0, -127 };  // 0x00000081
String s = new String(b,StandardCharsets.UTF_8); // UTF8 = 0x0000, 0x0000,  0x0000, 0xfffd
b = s.getBytes(StandardCharsets.UTF_8); // [0, 0, 0, -17, -65, -67] 0x000000efbfbd != 0x00000081

Ich würde b [] dasselbe Array vor und nach der Codierung benötigen, was es nicht ist (dies bezieht sich auf die erste Antwort).

//query is your json   

 DefaultHttpClient httpClient = new DefaultHttpClient();
 HttpPost postRequest = new HttpPost("http://my.site/test/v1/product/search?qy=");

 StringEntity input = new StringEntity(query, "UTF-8");
 input.setContentType("application/json");
 postRequest.setEntity(input);   
 HttpResponse response=response = httpClient.execute(postRequest);

Charset UTF8_CHARSET = Charset.forName("UTF-8");
String strISO = "{\"name\":\"א\"}";
System.out.println(strISO);
byte[] b = strISO.getBytes();
for (byte c: b) {
    System.out.print("[" + c + "]");
}
String str = new String(b, UTF8_CHARSET);
System.out.println(str);

Reader reader = new BufferedReader(
    new InputStreamReader(
        new ByteArrayInputStream(
            string.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8));

schrecklich spät, aber ich bin gerade auf dieses Problem gestoßen und dies ist meine Lösung:

private static String removeNonUtf8CompliantCharacters( final String inString ) {
    if (null == inString ) return null;
    byte[] byteArr = inString.getBytes();
    for ( int i=0; i < byteArr.length; i++ ) {
        byte ch= byteArr[i]; 
        // remove any characters outside the valid UTF-8 range as well as all control characters
        // except tabs and new lines
        if ( !( (ch > 31 && ch < 253 ) || ch == '\t' || ch == '\n' || ch == '\r') ) {
            byteArr[i]=' ';
        }
    }
    return new String( byteArr );
}