UTF-8 byte [] thành Chuỗi

Giả sử tôi vừa sử dụng a BufferedInputStreamđể đọc các byte của tệp văn bản được mã hóa UTF-8 thành một mảng byte. Tôi biết rằng tôi có thể sử dụng thói quen sau đây để chuyển đổi các byte thành một chuỗi, nhưng có cách nào hiệu quả hơn / thông minh hơn để thực hiện việc này hơn là chỉ lặp qua các byte và chuyển đổi từng byte không?

public String openFileToString(byte[] _bytes)
{
    String file_string = "";

    for(int i = 0; i < _bytes.length; i++)
    {
        file_string += (char)_bytes[i];
    }

    return file_string;    
}

Nhìn vào hàm tạo cho String

String str = new String(bytes, StandardCharsets.UTF_8);

Và nếu bạn cảm thấy lười biếng, bạn có thể sử dụng thư viện IO Commons IO để chuyển trực tiếp InputStream thành Chuỗi:

String str = IOUtils.toString(inputStream, StandardCharsets.UTF_8);

Lớp Chuỗi Java có một hàm tạo dựng sẵn để chuyển đổi mảng byte thành chuỗi.

byte[] byteArray = new byte[] {87, 79, 87, 46, 46, 46};

String value = new String(byteArray, "UTF-8");

Để chuyển đổi dữ liệu utf-8, bạn không thể giả sử sự tương ứng 1-1 giữa các byte và ký tự. Thử cái này:

String file_string = new String(bytes, "UTF-8");

(Bah. Tôi thấy tôi có cách chậm để nhấn nút Đăng câu trả lời của bạn.)

Để đọc toàn bộ tệp dưới dạng Chuỗi, hãy thực hiện như sau:

public String openFileToString(String fileName) throws IOException
{
    InputStream is = new BufferedInputStream(new FileInputStream(fileName));

    try {
        InputStreamReader rdr = new InputStreamReader(is, "UTF-8");
        StringBuilder contents = new StringBuilder();
        char[] buff = new char[4096];
        int len = rdr.read(buff);
        while (len >= 0) {
            contents.append(buff, 0, len);
        }
        return buff.toString();
    } finally {
        try {
            is.close();
        } catch (Exception e) {
            // log error in closing the file
        }
    }
}

Bạn có thể sử dụng hàm String(byte[] bytes) tạo cho điều đó. Xem liên kết này để biết chi tiết. EDIT Bạn cũng phải xem xét bộ ký tự mặc định của biểu mẫu của bạn theo tài liệu java:

Xây dựng một Chuỗi mới bằng cách giải mã mảng byte được chỉ định bằng bộ ký tự mặc định của nền tảng. Độ dài của Chuỗi mới là một hàm của bộ ký tự và do đó có thể không bằng độ dài của mảng byte. Hành vi của hàm tạo này khi các byte đã cho không hợp lệ trong bộ ký tự mặc định là không xác định. Lớp CharsetDecoder nên được sử dụng khi cần kiểm soát nhiều hơn quá trình giải mã.

Bạn có thể sử dụng các phương thức được mô tả trong câu hỏi này (đặc biệt là khi bạn bắt đầu với InputStream): Đọc / chuyển đổi InputStream thành Chuỗi

Cụ thể, nếu bạn không muốn dựa vào các thư viện bên ngoài, bạn có thể thử câu trả lời này , đọc InputStreamthông qua InputStreamReadermột char[]bộ đệm và nối nó vào một StringBuilder.

Biết rằng bạn đang xử lý một mảng byte UTF-8, chắc chắn bạn sẽ muốn sử dụng hàm tạo Chuỗi chấp nhận tên bộ ký tự . Nếu không, bạn có thể để mình mở cho một số lỗ hổng bảo mật dựa trên mã hóa bộ ký tự. Lưu ý rằng nó ném UnsupportedEncodingExceptionmà bạn sẽ phải xử lý. Một cái gì đó như thế này:

public String openFileToString(String fileName) {
    String file_string;
    try {
        file_string = new String(_bytes, "UTF-8");
    } catch (UnsupportedEncodingException e) {
        // this should never happen because "UTF-8" is hard-coded.
        throw new IllegalStateException(e);
    }
    return file_string;
}

Đây là một hàm đơn giản hóa sẽ đọc theo byte và tạo một chuỗi. Nó giả định rằng bạn có thể đã biết mã hóa tệp trong đó (và nếu không thì mặc định).

static final int BUFF_SIZE = 2048;
static final String DEFAULT_ENCODING = "utf-8";

public static String readFileToString(String filePath, String encoding) throws IOException {

    if (encoding == null || encoding.length() == 0)
        encoding = DEFAULT_ENCODING;

    StringBuffer content = new StringBuffer();

    FileInputStream fis = new FileInputStream(new File(filePath));
    byte[] buffer = new byte[BUFF_SIZE];

    int bytesRead = 0;
    while ((bytesRead = fis.read(buffer)) != -1)
        content.append(new String(buffer, 0, bytesRead, encoding));

    fis.close();        
    return content.toString();
}

Chuỗi có một hàm tạo lấy byte [] và charsetname làm tham số :)

Điều này cũng liên quan đến việc lặp lại, nhưng điều này tốt hơn nhiều so với việc nối các chuỗi vì chúng rất rất tốn kém.

public String openFileToString(String fileName)
{
    StringBuilder s = new StringBuilder(_bytes.length);

    for(int i = 0; i < _bytes.length; i++)
    {
        s.append((char)_bytes[i]);
    }

    return s.toString();    
}

Tại sao không nhận được những gì bạn đang tìm kiếm từ việc di chuyển và đọc một chuỗi từ tệp thay vì một mảng byte? Cái gì đó như:

BufferedReader in = new BufferedReader(new InputStreamReader( new FileInputStream( "foo.txt"), Charset.forName( "UTF-8"));

sau đó đọcLine từ trong cho đến khi hoàn thành.

Tôi dùng cách này

String strIn = new String(_bytes, 0, numBytes);