Como converter seqüências de caracteres de e para matrizes de bytes UTF8 em Java

Em Java, eu tenho uma String e quero codificá-la como uma matriz de bytes (em UTF8 ou alguma outra codificação). Como alternativa, tenho uma matriz de bytes (em alguma codificação conhecida) e desejo convertê-la em uma String Java. Como faço essas conversões?

Converter de String em byte []:

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

Converter de byte [] em String:

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

Obviamente, você deve usar o nome de codificação correto. Meus exemplos usaram US-ASCII e UTF-8, as duas codificações mais comuns.

Aqui está uma solução que evita realizar a pesquisa Charset para cada conversão:

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");

Você pode converter diretamente por meio do construtor String (byte [], String) e do método getBytes (String). Java expõe conjuntos de caracteres disponíveis por meio da classe Charset . A documentação do JDK lista as codificações suportadas .

90% do tempo, essas conversões são realizadas em fluxos, portanto, você usaria as classes Reader / Writer . Você não decodificaria incrementalmente usando os métodos String em fluxos de bytes arbitrários - se deixaria aberto a erros que envolvem caracteres multibyte.

Minha implementação do tomcat7 está aceitando strings como ISO-8859-1; apesar do tipo de conteúdo da solicitação HTTP. A solução a seguir funcionou para mim ao tentar interpretar corretamente caracteres como 'é'.

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

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

Ao tentar interpretar a sequência como US-ASCII, as informações do byte não foram interpretadas corretamente.

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

Como alternativa, o StringUtils do Apache Commons pode ser usado.

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

ou

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

Se você possui um conjunto de caracteres não padrão, pode usar getBytesUnchecked () ou newString () de acordo.

Para decodificar uma série de bytes em uma mensagem de string normal, finalmente consegui trabalhar com a codificação UTF-8 com este código:

/* 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"));
}

Se você estiver usando ASCII de 7 bits ou ISO-8859-1 (um formato surpreendentemente comum), não precisará criar um novo java.lang.String . É muito mais eficiente simplesmente converter o byte em char:

Exemplo de trabalho completo:

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

Se você não estiver usando caracteres estendidos como Ä, Æ, Å, Ç, Ï, Ê e pode ter certeza de que os únicos valores transmitidos são dos primeiros 128 caracteres Unicode, esse código também funcionará para UTF-8 e ASCII estendido. (como cp-1252).

Não posso comentar, mas não quero iniciar um novo tópico. Mas isso não está funcionando. Uma simples ida e volta:

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

Eu precisaria da mesma matriz antes e depois da codificação que não é (isso se refere à primeira resposta).

//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));

terrivelmente tarde, mas eu apenas encontrei esse problema e esta é a minha correção:

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 );
}