Como converter Strings 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 outra codificação). Como alternativa, tenho uma matriz de bytes (em alguma codificação conhecida) e quero convertê-la em uma string Java. Como faço essas conversões?

   

Converter de string para byte []:

String s = "some text here"; byte[] b = s.getBytes("UTF-8"); 

Converter de byte [] para String:

 byte[] b = {(byte) 99, (byte)97, (byte)116}; String s = new String(b, "US-ASCII"); 

Você deve, obviamente, usar o nome de codificação correto. Meus exemplos usavam “US-ASCII” e “UTF-8”, as duas codificações mais comuns.

Aqui está uma solução que evita a realização da 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 através do construtor String (byte [], String) e método getBytes (String). Java expõe conjuntos de caracteres disponíveis através da class Charset . A documentação do JDK lista as codificações suportadas .

Em 90% do tempo, essas conversões são realizadas em streams, então você usaria as classs Reader / Writer . Você não decodificaria incrementalmente usando os methods String em streams de byte arbitrários – você ficaria aberto a bugs envolvendo 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 string como US-ASCII, as informações de 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ê tiver um conjunto de caracteres não padrão, poderá usar getBytesUnchecked () ou newString () de acordo.

Se você estiver usando ASCII de 7 bits ou ISO-8859-1 (um formato incrivelmente comum), não precisará criar um novo java.lang.String . É muito mais produtivo 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, então este código também funcionará para UTF-8 e ASCII estendido. (como cp-1252).

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

Não posso comentar mas não quero começar 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 de b [] a mesma matriz antes e depois da codificação, o que não é (isso se refere à primeira resposta).

 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 atrasado, mas eu apenas encontrei este 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 ); }