Java I/O meistern: Dateien, Streams und Ein-/Ausgabe-Grundlagen

Einführung in Java I/O

Das Paket java.io enthält nahezu jede Klasse, die Sie jemals benötigen könnten, um Eingabe und Ausgabe (I/O) in Java durchzuführen. All diese Streams repräsentieren eine Eingabequelle und ein Ausgabeziel. Der Stream im java.io-Paket unterstützt viele Datentypen wie Primitiven, Objekte, lokalisierte Zeichen usw.

Streams (Datenströme)

Ein Stream kann als eine Sequenz von Daten definiert werden. Es gibt zwei Arten von Streams:

InputStream – Der InputStream wird verwendet, um Daten von einer Quelle zu lesen.
OutputStream – Der OutputStream wird verwendet, um Daten in ein Ziel zu schreiben.

Java bietet starke, aber flexible Unterstützung für I/O im Zusammenhang mit Dateien und Netzwerken, aber dieses Tutorial deckt nur die grundlegendste Funktionalität im Zusammenhang mit Streams und I/O ab. Wir werden die am häufigsten verwendeten Beispiele Schritt für Schritt betrachten.

Byte Streams

Java Byte Streams werden verwendet, um Ein- und Ausgabe von 8-Bit-Bytes durchzuführen. Obwohl es viele Klassen im Zusammenhang mit Byte Streams gibt, sind die am häufigsten verwendeten Klassen FileInputStream und FileOutputStream. Das folgende Beispiel nutzt diese beiden Klassen, um eine Eingabedatei in eine Ausgabedatei zu kopieren:

Beispiel

import java.io.*;

public class CopyFile {
    public static void main(String args[]) throws IOException {
        FileInputStream in = null;
        FileOutputStream out = null;
        try {
            in = new FileInputStream("input.txt");
            out = new FileOutputStream("output.txt");
            int c;
            while ((c = in.read()) != -1) {
                out.write(c);
            }
        } finally {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }
        }
    }
}

Angenommen, wir haben eine Datei input.txt mit folgendem Inhalt:

This is test for copy file.

Als nächsten Schritt kompilieren und führen wir das obige Programm aus, was zur Erstellung der Datei output.txt mit demselben Inhalt wie in input.txt führt.

Character Streams

Java Byte Streams werden für die Ein- und Ausgabe von 8-Bit-Bytes verwendet, wohingegen Java Character Streams für die Ein- und Ausgabe von 16-Bit-Unicode verwendet werden. Obwohl es viele Klassen im Zusammenhang mit Character Streams gibt, sind die am häufigsten verwendeten Klassen FileReader und FileWriter. Zwar verwendet FileReader intern FileInputStream und FileWriter intern FileOutputStream, aber der Hauptunterschied besteht darin, dass FileReader zwei Bytes auf einmal liest und FileWriter zwei Bytes auf einmal schreibt.

Wir können das obige Beispiel neu schreiben, um diese beiden Klassen zu verwenden, um eine Eingabedatei (mit Unicode-Zeichen) in eine Ausgabedatei zu kopieren:

Beispiel

import java.io.*;

public class CopyFile {
    public static void main(String args[]) throws IOException {
        FileReader in = null;
        FileWriter out = null;
        try {
            in = new FileReader("input.txt");
            out = new FileWriter("output.txt");
            int c;
            while ((c = in.read()) != -1) {
                out.write(c);
            }
        } finally {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }
        }
    }
}

Standard Streams

Alle Programmiersprachen bieten Unterstützung für Standard-I/O, bei der das Programm des Benutzers Eingaben von einer Tastatur entgegennehmen und dann eine Ausgabe auf dem Bildschirm erzeugen kann. Wenn Sie C oder C++ kennen, dann müssen Sie die drei Standardgeräte STDIN, STDOUT und STDERR kennen. Ebenso bietet Java die folgenden drei Standard-Streams:

Standard Input – Wird verwendet, um Daten in das Programm des Benutzers einzuspeisen. Normalerweise wird eine Tastatur als Standard-Eingabestream verwendet und als System.in dargestellt.
Standard Output – Wird verwendet, um die vom Programm des Benutzers erzeugten Daten auszugeben. Normalerweise wird ein Bildschirm für den Standard-Ausgabestream verwendet und als System.out dargestellt.
Standard Error – Wird verwendet, um die vom Programm des Benutzers erzeugten Fehlere Daten auszugeben. Normalerweise wird ein Bildschirm für den Standard-Fehlerstream verwendet und als System.err dargestellt.

Beispiel: Konsoleneingabe lesen

Das folgende einfache Programm erstellt einen InputStreamReader, um den Standard-Eingabestream zu lesen, bis der Benutzer ein "q" eingibt:

import java.io.*;

public class ReadConsole {
    public static void main(String args[]) throws IOException {
        InputStreamReader cin = null;
        try {
            cin = new InputStreamReader(System.in);
            System.out.println("Enter characters, 'q' to quit.");
            char c;
            do {
                c = (char) cin.read();
                System.out.print(c);
            } while (c != 'q');
        } finally {
            if (cin != null) {
                cin.close();
            }
        }
    }
}

Speichern Sie den Code in ReadConsole.java und kompilieren/ausführen:

$ javac ReadConsole.java
$ java ReadConsole
Enter characters, 'q' to quit.
1 1 e e q q

Dateien lesen und schreiben

Wie bereits beschrieben, kann ein Stream als eine Sequenz von Daten definiert werden. Der InputStream wird verwendet, um Daten von einer Quelle zu lesen, und der OutputStream wird verwendet, um Daten in ein Ziel zu schreiben.

FileInputStream

Dieser Stream wird zum Lesen von Daten aus Dateien verwendet. Objekte können mit dem Schlüsselwort new erstellt werden, und es stehen verschiedene Konstruktortypen zur Verfügung.

Der folgende Konstruktor nimmt einen Dateinamen als String entgegen, um ein Eingabestream-Objekt zum Lesen der Datei zu erstellen:

InputStream f = new FileInputStream("C:/java/hello");

Der folgende Konstruktor nimmt ein File-Objekt entgegen, um ein Eingabestream-Objekt zum Lesen der Datei zu erstellen. Zuerst erstellen wir ein File-Objekt mit der File()-Methode:

File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);

Sobald Sie ein InputStream-Objekt haben, gibt es eine Liste von Hilfsmethoden, die zum Lesen des Streams oder für andere Operationen auf dem Stream verwendet werden können:

Nr.	Methode & Beschreibung
1	`public void close() throws IOException` – Schließt den Datei-Eingabestream. Gibt alle mit der Datei verbundenen Systemressourcen frei. Wirft eine IOException.
2	`protected void finalize() throws IOException` – Bereinigt die Verbindung zur Datei. Stellt sicher, dass die close-Methode dieses Datei-Eingabestreams aufgerufen wird, wenn keine weiteren Referenzen auf diesen Stream mehr existieren. Wirft eine IOException.
3	`public int read(int r) throws IOException` – Liest das angegebene Byte an Daten aus dem InputStream. Gibt ein int zurück. Gibt das nächste Byte an Daten zurück und -1, wenn es das Dateiende ist.
4	`public int read(byte[] r) throws IOException` – Liest r.length Bytes aus dem Eingabestream in ein Array. Gibt die Gesamtzahl der gelesenen Bytes zurück. Wenn es das Dateiende ist, wird -1 zurückgegeben.
5	`public int available() throws IOException` – Gibt die Anzahl der Bytes zurück, die aus diesem Datei-Eingabestream gelesen werden können. Gibt ein int zurück.

Weitere wichtige Eingabestreams:

ByteArrayInputStream
DataInputStream

FileOutputStream

FileOutputStream wird verwendet, um eine Datei zu erstellen und Daten hineinzuschreiben. Der Stream würde die Datei erstellen, falls sie noch nicht existiert, bevor er sie für die Ausgabe öffnet.

Hier sind zwei Konstruktoren, die verwendet werden können, um ein FileOutputStream-Objekt zu erstellen:

Konstruktor mit Dateinamen als String:

OutputStream f = new FileOutputStream("C:/java/hello")

Konstruktor mit File-Objekt:

File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

Sobald Sie ein OutputStream-Objekt haben, gibt es eine Liste von Hilfsmethoden, die zum Schreiben in den Stream oder für andere Operationen verwendet werden können:

Nr.	Methode & Beschreibung
1	`public void close() throws IOException` – Schließt den Datei-Ausgabestream. Gibt alle mit der Datei verbundenen Systemressourcen frei. Wirft eine IOException.
2	`protected void finalize() throws IOException` – Bereinigt die Verbindung zur Datei. Stellt sicher, dass die close-Methode dieses Datei-Ausgabestreams aufgerufen wird, wenn keine weiteren Referenzen auf diesen Stream mehr existieren. Wirft eine IOException.
3	`public void write(int w) throws IOException` – Schreibt das angegebene Byte in den Ausgabestream.
4	`public void write(byte[] w)` – Schreibt w.length Bytes aus dem genannten Byte-Array in den OutputStream.

Weitere wichtige Ausgabestreams:

ByteArrayOutputStream
DataOutputStream

Beispiel: InputStream und OutputStream demonstrieren

import java.io.*;

public class FileStreamTest {
    public static void main(String args[]) {
        try {
            byte bWrite[] = {11, 21, 3, 40, 5};
            OutputStream os = new FileOutputStream("test.txt");
            for (int x = 0; x < bWrite.length; x++) {
                os.write(bWrite[x]); // Bytes schreiben
            }
            os.close();

            InputStream is = new FileInputStream("test.txt");
            int size = is.available();
            for (int i = 0; i < size; i++) {
                System.out.print((char) is.read() + " ");
            }
            is.close();
        } catch (IOException e) {
            System.out.print("Exception");
        }
    }
}

Der obige Code würde die Datei test.txt erstellen und die gegebenen Zahlen im Binärformat schreiben. Dasselbe wäre die Ausgabe auf dem stdout-Bildschirm.

Dateinavigation und I/O

Es gibt mehrere weitere Klassen, die wir durchgehen, um die Grundlagen der Dateinavigation und I/O kennenzulernen:

File Klasse
FileReader Klasse
FileWriter Klasse

Verzeichnisse in Java

Ein Verzeichnis ist ein File, das eine Liste anderer Dateien und Verzeichnisse enthalten kann. Sie verwenden ein File-Objekt, um Verzeichnisse zu erstellen und Dateien aufzulisten, die in einem Verzeichnis verfügbar sind.

Verzeichnisse erstellen

Es gibt zwei nützliche File-Hilfsmethoden, die zum Erstellen von Verzeichnissen verwendet werden können:

Die mkdir()-Methode erstellt ein Verzeichnis und gibt bei Erfolg true und bei Fehlschlag false zurück. Ein Fehlschlag bedeutet, dass der im File-Objekt angegebene Pfad bereits existiert oder dass das Verzeichnis nicht erstellt werden kann, weil der gesamte Pfad noch nicht existiert.
Die mkdirs()-Methode erstellt sowohl ein Verzeichnis als auch alle übergeordneten Verzeichnisse.

Beispiel: "/tmp/user/java/bin" erstellen

import java.io.File;

public class CreateDir {
    public static void main(String args[]) {
        String dirname = "/tmp/user/java/bin";
        File d = new File(dirname);
        // Verzeichnis jetzt erstellen
        d.mkdirs();
    }
}

Kompilieren und ausführen, um "/tmp/user/java/bin" zu erstellen.

Hinweis – Java kümmert sich automatisch um Pfadtrennzeichen auf UNIX und Windows gemäß Konventionen. Wenn Sie einen Vorwärtsschrägstrich (/) auf einer Windows-Version von Java verwenden, wird der Pfad trotzdem korrekt aufgelöst.

Verzeichnisse auflisten

Sie können die list()-Methode verwenden, die vom File-Objekt bereitgestellt wird, um alle Dateien und Verzeichnisse aufzulisten, die in einem Verzeichnis verfügbar sind:

Beispiel

import java.io.File;

public class ReadDir {
    public static void main(String[] args) {
        File file = null;
        String[] paths;
        try {
            // neues File-Objekt erstellen
            file = new File("/tmp");
            // Array von Dateien und Verzeichnissen
            paths = file.list();
            // für jeden Namen im Pfad-Array
            for (String path : paths) {
                // Dateiname und Verzeichnisname ausgeben
                System.out.println(path);
            }
        } catch (Exception e) {
            // falls ein Fehler auftritt
            e.printStackTrace();
        }
    }
}

Dies erzeugt ein Ergebnis basierend auf den in Ihrem /tmp-Verzeichnis verfügbaren Verzeichnissen und Dateien:

test1.txt
test2.txt
ReadDir.java
ReadDir.class

Java Methoden meistern: Erstellen, Aufrufen und Abstraktion Java Exceptions meistern: Unerwartete Fehler elegant behandeln

Java