Cách chuyển đổi Chuỗi sang và từ mảng byte UTF8 trong Java

Trong Java, tôi có một Chuỗi và tôi muốn mã hóa nó dưới dạng một mảng byte (trong UTF8 hoặc một số mã hóa khác). Thay phiên, tôi có một mảng byte (trong một số mã hóa đã biết) và tôi muốn chuyển đổi nó thành Chuỗi Java. Làm cách nào để thực hiện các chuyển đổi này?

Chuyển đổi từ Chuỗi sang byte []:

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

Chuyển đổi từ byte [] thành Chuỗi:

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

Tất nhiên, bạn nên sử dụng tên mã hóa chính xác. Các ví dụ của tôi đã sử dụng US-ASCII và UTF-8, hai bảng mã phổ biến nhất.

Đây là một giải pháp tránh thực hiện tra cứu Charset cho mọi chuyển đổi:

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

Bạn có thể chuyển đổi trực tiếp thông qua phương thức khởi tạo String (byte [], String) và phương thức getBytes (String). Java trưng bày các bộ ký tự có sẵn thông qua lớp Charset . Tài liệu JDK liệt kê các bảng mã được hỗ trợ .

90% thời gian, các chuyển đổi như vậy được thực hiện trên các luồng, vì vậy bạn sẽ sử dụng các lớp Reader / Writer . Bạn sẽ không giải mã tăng dần bằng cách sử dụng các phương thức Chuỗi trên các luồng byte tùy ý - bạn sẽ để ngỏ cho các lỗi liên quan đến các ký tự đa dòng.

Việc triển khai tomcat7 của tôi đang chấp nhận các chuỗi là ISO-8859-1; mặc dù kiểu nội dung của yêu cầu HTTP. Giải pháp sau đây có hiệu quả với tôi khi cố gắng diễn giải chính xác các ký tự như 'é'.

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

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

Khi cố gắng diễn giải chuỗi là US-ASCII, thông tin byte không được hiểu chính xác.

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

Thay thế, StringUtils từ Apache Commons có thể được sử dụng.

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

hoặc là

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

Nếu bạn có bộ ký tự không chuẩn, bạn có thể sử dụng getBytesUnchecked () hoặc newString () tương ứng.

Để giải mã một loạt byte thành thông điệp chuỗi bình thường, cuối cùng tôi đã làm cho nó hoạt động với mã hóa UTF-8 với mã này:

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

Nếu bạn đang sử dụng ASCII 7 bit hoặc ISO-8859-1 (một định dạng phổ biến đáng kinh ngạc) thì bạn hoàn toàn không phải tạo java.lang.String mới . Sẽ hiệu quả hơn nhiều khi chỉ cần chuyển byte thành char:

Ví dụ làm việc đầy đủ:

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

Nếu bạn không sử dụng các ký tự mở rộng như,, Å,, Ï, Ê và có thể chắc chắn rằng các giá trị được truyền duy nhất là của 128 ký tự Unicode đầu tiên, thì mã này cũng sẽ hoạt động cho UTF-8 và ASCII mở rộng (như cp-1252).

Tôi không thể bình luận nhưng không muốn bắt đầu một chủ đề mới. Nhưng điều này không hiệu quả. Một chuyến đi khứ hồi đơn giản:

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

Tôi cần b [] cùng một mảng trước và sau khi mã hóa nó không phải (điều này đề cập đến câu trả lời đầu tiên).

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

cực kỳ muộn nhưng tôi chỉ gặp phải vấn đề này và đây là cách khắc phục của tôi:

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