UTF-8 Byte [] zu String

Nehmen wir an, ich habe gerade a verwendet BufferedInputStream, um die Bytes einer UTF-8-codierten Textdatei in ein Byte-Array zu lesen. Ich weiß, dass ich die folgende Routine verwenden kann, um die Bytes in eine Zeichenfolge zu konvertieren. Gibt es jedoch eine effizientere / intelligentere Methode, als nur die Bytes zu durchlaufen und jedes einzelne zu konvertieren?

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

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

    return file_string;    
}

Schauen Sie sich den Konstruktor für String an

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

Und wenn Sie sich faul fühlen, können Sie den InputStream mithilfe der Apache Commons IO- Bibliothek direkt in einen String konvertieren:

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

Die Java String-Klasse verfügt über einen integrierten Konstruktor zum Konvertieren eines Byte-Arrays in einen String.

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

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

Um utf-8-Daten zu konvertieren, können Sie keine 1-1-Entsprechung zwischen Bytes und Zeichen annehmen. Versuche dies:

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

(Bah. Ich sehe, ich bin viel zu langsam, wenn ich auf die Schaltfläche "Antwort posten" drücke.)

Gehen Sie folgendermaßen vor, um eine gesamte Datei als Zeichenfolge zu lesen:

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

Sie können den String(byte[] bytes) Konstruktor dafür verwenden. Siehe diesen Link für Details. BEARBEITEN Sie müssen auch den Standardzeichensatz Ihrer Plattenform gemäß dem Java-Dokument berücksichtigen:

Erstellt einen neuen String, indem das angegebene Bytearray mit dem Standardzeichensatz der Plattform dekodiert wird. Die Länge des neuen Strings ist eine Funktion des Zeichensatzes und entspricht daher möglicherweise nicht der Länge des Bytearrays. Das Verhalten dieses Konstruktors, wenn die angegebenen Bytes im Standardzeichensatz nicht gültig sind, ist nicht angegeben. Die CharsetDecoder-Klasse sollte verwendet werden, wenn mehr Kontrolle über den Decodierungsprozess erforderlich ist.

Sie können die in dieser Frage beschriebenen Methoden verwenden (insbesondere, da Sie mit einem InputStream beginnen): Lesen / Konvertieren eines InputStream in einen String

Insbesondere wenn Sie sich nicht auf externe Bibliotheken verlassen möchten, können Sie diese Antwort ausprobieren , bei der das InputStreamVia über ein InputStreamReaderin einen char[]Puffer gelesen und an ein angehängt wird StringBuilder.

Wenn Sie wissen, dass es sich um ein UTF-8-Byte-Array handelt, sollten Sie auf jeden Fall den String-Konstruktor verwenden, der einen Zeichensatznamen akzeptiert . Andernfalls können Sie sich einigen Sicherheitslücken auf der Basis von Zeichensatzcodierung aussetzen. Beachten Sie, dass es wirft, mit UnsupportedEncodingExceptiondenen Sie umgehen müssen. Etwas wie das:

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

Hier ist eine vereinfachte Funktion, die Bytes einliest und eine Zeichenfolge erstellt. Es wird davon ausgegangen, dass Sie wahrscheinlich bereits wissen, in welcher Codierung sich die Datei befindet (und ansonsten standardmäßig).

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 hat einen Konstruktor, der Byte [] und Zeichensatznamen als Parameter verwendet :)

Dies beinhaltet auch das Iterieren, aber dies ist viel besser als das Verketten von Zeichenfolgen, da diese sehr, sehr kostspielig sind.

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

Warum nicht gleich von Anfang an das bekommen, wonach Sie suchen, und statt eines Arrays von Bytes einen String aus der Datei lesen? Etwas wie:

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

dann readLine von in bis es fertig ist.

Ich benutze diesen Weg

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