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:
- Die ausgelesenen Zeilen werden vom
Scanner
ohne Zeilenumbruchszeichen zurückgegeben. Für eine zeilenweise Weiterverarbeitung muss, wie oben etwa durch Verwendung vonprintln()
stattprint()
, gesondert geachtet werden. Gesetz den Fall test.txt enthielte den folgenden EintragZeile 1 Zeile 2 Zeile 3
dann ergäbe die obige Notation eine identische Ausgabe auf der Konsole. Eine Verwendung vonprint()
liefert jedochSystem.out.print(scan.nextLine()); // Zeile 1Zeile 2Zeile 3
- Der ausgelesene Inhalt des
Scanner
-Objektes wird nach Rückgabe verworfen. Auch ein mehrfaches Durchlaufen desScanner
-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