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
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(); }
Wenn Ihnen javabeginners.de gefällt, freue ich mich über eine Spende an diese gemeinnützigen Organisationen.