Wie kann eine Textdatei zeilenweise ausgelesen werden?

BufferedReader

In der main-Methode des Beispiels wird die Methode ladeDatei() aufgerufen, der der Dateiname der auszulesenden Datei als Parameter übergeben wird. In ihr werden zunächst die Existenz der Datei und ihre Lesbarkeit überprüft.

Der folgende try-catch-Block fängt Fehler ab, die während des Auslesens der Datei auftreten können. Der Vorgang selbst wird durch einen BufferedReader durchgeführt, dem ein FileReader übergeben wird, der wiederum den Dateinamen als Argument erhält. Die Klasse BufferedReader enthält die Methode readLine(), die eine Zeile als String-Objekt zurückgibt. Als Zeilenende werden entweder line feed ("\n"), carriage return ("\r") oder die Kombination aus beidem ("\r\n") erkannt.
In einer while-Schleife wird readLine() so lange aufgerufen, wie nicht null zurück gegeben wird.
Die Ausgabe wird bei jedem Schleifendurchlauf auf der Konsole ausgegeben.

Zur Demonstration wird zusätzlich ein StringBuffer-Objekt erzeugt, dem in der Schleife die ausgelesenen Zeilen zusammen mit einem folgenden Zeilenumbruchszeichen übergeben werden. Nach Beendigung der Schleife kann es in ein String-Objekt gewandelt und weiterverwendet - hier ausgegeben - werden.

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class DateiZeilenweiseAuslesenClass {

    private static void ladeDatei(String datName) {

        File file = new File(datName);

        if (!file.canRead() || !file.isFile())
            System.exit(0);

            BufferedReader in = null;
        try {
            in = new BufferedReader(new FileReader(datName));
            String zeile = null;
            while ((zeile = in.readLine()) != null) {
                System.out.println("Gelesene Zeile: " + zeile);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (in != null)
                try {
                    in.close();
                } catch (IOException e) {
                }
        }
    }

    public static void main(String[] args) {
        String dateiName = "test.txt";
        ladeDatei(dateiName);
    }
}

Scanner

Eine weitere, deutlich einfachere Möglichkeit besteht in der Nutzung eines Scanner-Objektes, das ab Java 1.5 bereitsteht. Die Klasse wird im gleichnamigen Artikel ausführlicher erläutert.

Das folgende Beispiel verwendet dessen Methode nextLine(), die jeweils, begrenzt durch ein Zeilenumbruchszeichen, eine vollständige Zeile zwischenspeichert und zurückgibt.

Scanner scan = null;
try {
    scan = new Scanner(new File("test.txt"));
} catch (FileNotFoundException e) {
    e.printStackTrace();
}
while (scan.hasNext()) {
   System.out.println(scan.nextLine());
}
scan.close();

Bei diesem Verfahren muss zweierlei beachtet werden:

1. Die ausgelesenen Zeilen werden vom Scanner ohne Zeilenumbruchszeichen zurückgegeben. Für eine zeilenweise Weiterverarbeitung muss, wie oben etwa durch Verwendung von println() statt print(), gesondert geachtet werden. Gesetz den Fall test.txt enthielte den folgenden Eintrag

   Zeile 1
   Zeile 2
   Zeile 3

   dann ergäbe die obige Notation eine identische Ausgabe auf der Konsole. Eine Verwendung von print() liefert jedoch

   System.out.print(scan.nextLine()); // Zeile 1Zeile 2Zeile 3

2. Der ausgelesene Inhalt des Scanner-Objektes wird nach Rückgabe verworfen. Auch ein mehrfaches Durchlaufen des Scanner-Objektes ist nicht möglich. Für eine mehrfache Weiterverwendung muss ein ausgelesenes Objekt zwischengespeichert werden.

   while (scan.hasNext()) {
       String s = scan.nextLine();
       System.out.println(s);
       System.out.println(s.toUpperCase());
   }
   while (scan.hasNext()) { // Schleife wird nicht betreten
       //...
   }

   Das Ergebnis sieht folgendermaßen aus:

   Zeile 1
   ZEILE 1
   Zeile 2
   ZEILE 2
   Zeile 3
   ZEILE 3

Streams

Seit Java 8 besteht die Möglichkeit des Auslesens mittels eines Stream. Ihn liefert die Methode lines() der Klasse java.nio.file.Files, die ein Path-Objekt als Parameter übergeben bekommt. Durch forEach() kann dann jede einzelne Zeile angesprochen und ausgegeben werden.

try (Stream<String> stream = Files.lines(Paths.get(datName))) {
    stream.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}