UTF-8 byte [] ke String

Misalkan saya baru saja menggunakan a BufferedInputStreamuntuk membaca byte dari file teks yang dikodekan UTF-8 ke dalam array byte. Saya tahu bahwa saya dapat menggunakan rutin berikut untuk mengkonversi byte ke string, tetapi apakah ada cara yang lebih efisien / lebih pintar untuk melakukan ini daripada hanya iterasi melalui byte dan mengkonversi masing-masing?

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

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

    return file_string;    
}

Lihatlah konstruktor untuk String

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

Dan jika Anda merasa malas, Anda dapat menggunakan pustaka Apache Commons IO untuk mengonversi InputStream menjadi sebuah String secara langsung:

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

Kelas Java String memiliki built-in-constructor untuk mengkonversi array byte ke string.

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

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

Untuk mengonversi data utf-8, Anda tidak dapat mengasumsikan korespondensi 1-1 antara byte dan karakter. Coba ini:

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

(Bah. Saya mengerti, saya cara memperlambat dalam menekan tombol Post Your Answer.)

Untuk membaca seluruh file sebagai String, lakukan sesuatu seperti ini:

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

Anda dapat menggunakan String(byte[] bytes) konstruktor untuk itu. Lihat tautan ini untuk detailnya. EDIT Anda juga harus mempertimbangkan charset default plateform Anda sesuai java doc:

Bangun String baru dengan mendekode array byte yang ditentukan menggunakan charset default platform. Panjang String baru adalah fungsi charset, dan karenanya mungkin tidak sama dengan panjang array byte. Perilaku konstruktor ini ketika byte yang diberikan tidak valid dalam charset default tidak ditentukan. Kelas CharsetDecoder harus digunakan ketika kontrol lebih besar atas proses decoding diperlukan.

Anda dapat menggunakan metode yang dijelaskan dalam pertanyaan ini (terutama karena Anda memulai dengan InputStream): Baca / konversi InputStream ke String

Secara khusus, jika Anda tidak ingin bergantung pada pustaka eksternal, Anda dapat mencoba jawaban ini , yang membaca InputStreamvia an InputStreamReaderke char[]buffer dan menambahkannya ke a StringBuilder.

Mengetahui bahwa Anda berurusan dengan array byte UTF-8, Anda pasti ingin menggunakan konstruktor String yang menerima nama charset . Kalau tidak, Anda dapat membiarkan diri Anda terbuka untuk beberapa kerentanan keamanan berbasis pengkodean charset. Perhatikan bahwa ia melempar UnsupportedEncodingExceptionyang harus Anda tangani. Sesuatu seperti ini:

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

Inilah fungsi yang disederhanakan yang akan membaca dalam byte dan membuat string. Ini mengasumsikan Anda mungkin sudah tahu di mana penyandian file (dan jika tidak, default).

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

String memiliki konstruktor yang menggunakan byte [] dan charsetname sebagai parameter :)

Ini juga melibatkan iterasi, tetapi ini jauh lebih baik daripada merangkai string karena mereka sangat sangat mahal.

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

Mengapa tidak mendapatkan apa yang Anda cari dari memulai dan membaca string dari file alih-alih array byte? Sesuatu seperti:

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

lalu bacaLine dari dalam sampai selesai.

Saya menggunakan cara ini

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