InputStream in Java in Zeichenfolge umwandeln

Einführung

In Java wird die Klasse InputStream verwendet, um Daten aus Dateien in einer bestimmten Reihenfolge zu lesen. Um die Daten als Zeichenfolge zu verwenden, müssen wir den InputStream in eine Zeichenfolge umwandeln. In diesem Lab werden Ihnen verschiedene Methoden gezeigt, wie ein InputStream in eine Zeichenfolge umgewandelt werden kann.

Verwendung von InputStreamReader

Die Klasse InputStreamReader bietet eine read()-Methode, um Daten aus einem InputStream in ein Zeichenarray zu lesen. Wir können das Zeichenarray in eine Zeichenfolge umwandeln. Erstellen Sie in Ihrem Projektverzeichnis ~/project eine neue Java-Quelldatei InputStreamToString.java mit dem folgenden Inhalt:

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class InputStreamToString {
    public static String inputStreamToString(InputStream input) throws IOException {
        InputStreamReader reader = new InputStreamReader(input);
        char[] charArray = new char[256];
        reader.read(charArray);
        return new String(charArray);
    }

    public static void main(String[] args) {
        try {
            InputStream input = new ByteArrayInputStream("hello world".getBytes());
            String strFromInputStream = inputStreamToString(input);
            System.out.print("String from the Input Stream is: " + strFromInputStream);
        } catch(Exception e) {
            System.out.print(e);
        }
    }
}

Um den Code auszuführen, öffnen Sie das Terminal und führen Sie den folgenden Befehl aus, um den Code zu kompilieren und auszuführen:

javac InputStreamToString.java && java InputStreamToString

Verwendung von InputStreamReader und BufferedReader mit StringBuilder

Der vorherige Schritt kann bei größeren Eingaben ineffizient sein. Stattdessen können wir einen BufferedReader verwenden, um den InputStreamReader zu umschließen, um die Effizienz zu verbessern. Anschließend werden wir ein StringBuilder-Objekt verwenden, um die Zeilen anzuhängen, die aus dem BufferedReader gelesen werden. Fügen Sie in InputStreamToString.java nach Schritt 1 einen neuen Schritt mit dem folgenden Code hinzu:

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class InputStreamToString {
    public static String inputStreamToString(InputStream input) throws IOException {
        StringBuilder builder = new StringBuilder();
        InputStreamReader reader = new InputStreamReader(input);
        BufferedReader bufferedReader = new BufferedReader(reader);
        String line;
        while ((line = bufferedReader.readLine())!= null) {
            builder.append(line);
        }
        return builder.toString();
    }

    public static void main(String[] args) {
        try {
            InputStream input = new ByteArrayInputStream("hello world".getBytes());
            String strFromInputStream = inputStreamToString(input);
            System.out.print("String from the Input Stream is: " + strFromInputStream);
        } catch(Exception e) {
            System.out.print(e);
        }
    }
}

Verwendung von InputStreamReader und BufferedReader ohne StringBuilder

Wir können einen einfachereren Ansatz verwenden, indem wir die lines()-Methode der BufferedReader-Klasse nutzen. Dadurch können wir das Anhängen jeder Zeile an eine separate StringBuilder-Instanz überspringen. Fügen Sie in InputStreamToString.java nach Schritt 2 einen neuen Schritt mit dem folgenden Code hinzu:

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.stream.Collectors;

public class InputStreamToString {
    public static String inputStreamToString(InputStream input) throws IOException {
        InputStreamReader reader = new InputStreamReader(input);
        BufferedReader bufferedReader = new BufferedReader(reader);
        String str = bufferedReader.lines().collect(Collectors.joining("\n"));
        return str;
    }

    public static void main(String[] args) {
        InputStream input = new ByteArrayInputStream("hello world".getBytes());
        String strFromInputStream = inputStreamToString(input);
        System.out.print("String from the Input Stream is: " + strFromInputStream);
    }
}

Verwendung der readAllBytes()-Methode des InputStream

Die Klasse InputStream hat in Java 9 die readAllBytes()-Methode eingeführt. Mit dieser Methode kann man das gesamte InputStream-Objekt in einem einzigen Codezeile effizient in eine Zeichenfolge umwandeln. Allerdings wird diese Methode für größere Eingaben nicht empfohlen. Fügen Sie in InputStreamToString.java nach Schritt 3 einen neuen Schritt mit dem folgenden Code hinzu:

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

public class InputStreamToString {
    public static String inputStreamToString(InputStream input) throws IOException {
        return new String(input.readAllBytes());
    }

    public static void main(String[] args) {
        try {
            InputStream input = new ByteArrayInputStream("hello world".getBytes());
            String strFromInputStream = inputStreamToString(input);
            System.out.print("String from the Input Stream is: " + strFromInputStream);
        } catch(Exception e) {
            System.out.print(e);
        }
    }
}

Verwendung der Scanner-Klasse

Wir können auch die Scanner-Klasse, eine häufig verwendete Klasse zum Lesen und Analysieren von Daten, verwenden, um den Eingabestream in eine Zeichenfolge umzuwandeln. Fügen Sie in InputStreamToString.java nach Schritt 4 einen neuen Schritt mit dem folgenden Code hinzu:

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;

public class InputStreamToString {
    public static String inputStreamToString(InputStream input) throws IOException {
        Scanner scanner = new Scanner(input);
        StringBuilder builder = new StringBuilder();
        while (scanner.hasNext()) {
            builder.append(scanner.nextLine());
        }
        return builder.toString();
    }

    public static void main(String[] args) {
        try {
            InputStream input = new ByteArrayInputStream("hello world".getBytes());
            String strFromInputStream = inputStreamToString(input);
            System.out.print("String from the Input Stream is: " + strFromInputStream);
        } catch(Exception e) {
            System.out.print(e);
        }
    }
}

Verwendung von ByteArrayOutputStream

Wir können die ByteArrayOutputStream-Klasse im java.io-Paket verwenden und Daten vom Eingabestream in das Byte-Array kopieren. Anschließend können wir das Byte-Array in die ByteArrayOutputStream schreiben. Schließlich werden wir die toString()-Methode der ByteArrayOutputStream verwenden, um die Zeichenfolgenrepräsentation zu erhalten. Fügen Sie in InputStreamToString.java nach Schritt 5 einen neuen Schritt mit dem folgenden Code hinzu:

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class InputStreamToString {
    public static String inputStreamToString(InputStream input) throws IOException {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[128];
        int length;
        while ((length = input.read(buffer))!= -1) {
            byteArrayOutputStream.write(buffer, 0, length);
        }
        return byteArrayOutputStream.toString();
    }

    public static void main(String[] args) {
        try {
            InputStream input = new ByteArrayInputStream("hello world".getBytes());
            String strFromInputStream = inputStreamToString(input);
            System.out.print("String from the Input Stream is: " + strFromInputStream);
        } catch(Exception e) {
            System.out.print(e);
        }
    }
}

Verwendung des java.nio-Pakets

Im java.nio-Paket können wir eine temporäre Datei mit Files.createTempFile erstellen und die Daten aus dem InputStream in diese Datei kopieren. Anschließend können wir den Inhalt dieser temporären Datei in eine Zeichenfolge lesen. Fügen Sie in InputStreamToString.java nach Schritt 6 einen neuen Schritt mit dem folgenden Code hinzu:

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

public class InputStreamToString {
    public static String inputStreamToString(InputStream input) throws IOException {
        Path file = Files.createTempFile(null, null);
        Files.copy(input, file, StandardCopyOption.REPLACE_EXISTING);
        return new String(Files.readAllBytes(file));
    }

    public static void main(String[] args) {
        try {
            InputStream input = new ByteArrayInputStream("hello world".getBytes());
            String strFromInputStream = inputStreamToString(input);
            System.out.print("String from the Input Stream is: " + strFromInputStream);
        } catch(Exception e) {
            System.out.print(e);
        }
    }
}

Verwendung der Google Guava-Bibliothek

Die Google Guava-Bibliothek bietet die CharStreams-Klasse an, um einen InputStream in eine Zeichenfolge umzuwandeln. Wir können die toString()-Methode dieser Klasse dazu verwenden. Sie nimmt ein Readable-Objekt (wie z. B. InputStreamReader) entgegen und liest die darin enthaltenen Daten in eine Zeichenfolge um. Fügen Sie in InputStreamToString.java nach Schritt 7 einen neuen Schritt mit dem folgenden Code hinzu:

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import com.google.common.io.CharStreams;

public class InputStreamToString {
    public static String inputStreamToString(InputStream input) throws IOException {
        try(InputStreamReader reader = new InputStreamReader(input)) {
            return CharStreams.toString(reader);
        }
    }

    public static void main(String[] args) {
        try {
            InputStream input = new ByteArrayInputStream("hello world".getBytes());
            String strFromInputStream = inputStreamToString(input);
            System.out.print("String from the Input Stream is: " + strFromInputStream);

        } catch(Exception e) {
            System.out.print(e);
        }
    }
}

Verwendung von Apache Commons IO

Die IOUtils-Klasse im org.apache.commons.io-Paket enthält ebenfalls eine toString()-Methode. Wir können direkt das InputStream-Objekt dieser Methode übergeben, und sie wird die darin enthaltenen Daten in eine Zeichenfolge lesen. Wir müssen auch eine Charset angeben. Fügen Sie in InputStreamToString.java nach Schritt 8 einen neuen Schritt mit dem folgenden Code hinzu:

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import org.apache.commons.io.IOUtils;

public class InputStreamToString {
    public static void main(String[] args) {
        try {
            InputStream input = new ByteArrayInputStream("hello world".getBytes());
            String strFromInputStream = IOUtils.toString(input, StandardCharsets.UTF_8.name());
            System.out.print("String from the Input Stream is: " + strFromInputStream);

        } catch(Exception e) {
            System.out.print(e);
        }
    }
}

Verwendung der StringWriter-Klasse mit Apache Commons IO

Wir können die StringWriter-Klasse des java.io-Pakets verwenden und den Inhalt des InputStream in die StringWriter kopieren. Wir werden die copy()-Methode der IOUtils-Klasse verwenden. Fügen Sie in InputStreamToString.java nach Schritt 9 einen neuen Schritt mit dem folgenden Code hinzu:

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.nio.charset.StandardCharsets;
import org.apache.commons.io.IOUtils;

public class InputStreamToString {
    public static void main(String[] args) {
        try {
            InputStream input = new ByteArrayInputStream("hello world".getBytes());
            StringWriter sw = new StringWriter();
            IOUtils.copy(input, sw, StandardCharsets.UTF_8.name());
            String strFromInputStream = sw.toString();
            System.out.print("String from the Input Stream is: " + strFromInputStream);

        } catch(Exception e) {
            System.out.print(e);
        }
    }
}

Zusammenfassung

In diesem Lab haben Sie verschiedene Methoden gelernt, um einen InputStream in Java in eine Zeichenfolge umzuwandeln. Sie können die ByteArrayOutputStream oder die BufferedReader-Klasse verwenden, um die Effizienz zu verbessern. Die Scanner-Klasse ist ebenfalls verfügbar, um den Eingabestream in eine Zeichenfolge umzuwandeln. Die readAllBytes()-Methode eignet sich nur für kleinere Eingaben. Wir können externe Bibliotheken wie die Google Guava oder Apache Commons IO verwenden, um den Prozess zu vereinfachen. Denken Sie daran, Ausnahmen zu behandeln und den InputStream zu schließen, um Ressourcenlecks zu vermeiden.

InputStream in Zeichenfolge umwandeln