Dateien und Pfade
Bisher sind alle Daten weg, sobald ein Programm endet. In diesem Kapitel
schreiben wir sie in Dateien und lesen sie wieder ein. Dafür gibt es im
Package java.nio.file zwei Hauptfiguren: Path beschreibt, wo eine Datei
liegt, und Files macht etwas mit ihr.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- einen Pfad zu einer Datei oder einem Ordner beschreiben
- eine ganze Datei als Text oder als Liste von Zeilen lesen und schreiben
- nachsehen, ob es eine Datei gibt, und sie kopieren, verschieben und löschen
- mit der
IOExceptionumgehen, die bei Dateien immer droht
Demo-Code: 22-dateien
⤓ demo-dateien.zip herunterladenDer fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.
Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 22-dateien wählen → OK → Trust Project. Zeigt IntelliJ oben Project JDK is not defined: auf Setup SDK klicken und das JDK 21 wählen.
Enthält: Pfade.java, DateiDemo.java, Dateiverwaltung.java
Path notizen = Path.of("daten", "notizen.txt");Ein Path ist eine Adresse – mehr nicht. Ob es die Datei dort wirklich
gibt, spielt keine Rolle. Path.of setzt die Teile mit dem Trennzeichen des
Betriebssystems zusammen: unter Windows \, unter Linux und macOS /.
package de.drv.dateien;
import java.nio.file.Path;
public class Pfade {
public static void main(String[] args) { // Ein relativer Pfad: Er gilt ab dem Arbeitsverzeichnis – in IntelliJ der Projektordner. Path notizen = Path.of("daten", "notizen.txt"); System.out.println("Pfad: " + notizen); System.out.println("Dateiname: " + notizen.getFileName()); System.out.println("Ordner: " + notizen.getParent()); System.out.println("absolut: " + notizen.toAbsolutePath());
// resolve hängt etwas an einen Pfad an Path daten = Path.of("daten"); Path archiv = daten.resolve("archiv").resolve("2026.txt"); System.out.println("archiv: " + archiv); }
}Pfad: daten\notizen.txtDateiname: notizen.txtOrdner: datenabsolut: C:\dev\intellij\22-dateien\daten\notizen.txtarchiv: daten\archiv\2026.txt- Relative Pfade wie
daten\notizen.txtgelten ab dem Arbeitsverzeichnis. Startest du ein Programm in IntelliJ, ist das der Projektordner – du findest ihn in der Run Configuration unter Working directory. - Absolute Pfade beginnen mit dem Laufwerk:
C:\dev\….toAbsolutePath()macht aus einem relativen Pfad einen absoluten. resolvehängt etwas an einen Pfad an – ein bequemer Weg, Pfade schrittweise zusammenzubauen.
Path ist übrigens ein Interface – ein Vertrag, wie wir sie kennen.
Path.of liefert eine Implementierung für das Betriebssystem, auf dem das
Programm gerade läuft: unter Windows ein WindowsPath, unter Linux ein
UnixPath. Unser Code merkt davon nichts.
Ganze Dateien lesen und schreiben
Abschnitt betitelt „Ganze Dateien lesen und schreiben“Für kleine Dateien – Notizen, Einstellungen, Listen – bietet Files Methoden,
die eine Datei auf einmal lesen oder schreiben:
package de.drv.dateien;
import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.StandardOpenOption;import java.util.List;
public class DateiDemo {
public static void main(String[] args) throws IOException { Files.createDirectories(Path.of("daten"));
// Einen ganzen Text schreiben und lesen Path gruss = Path.of("daten", "gruss.txt"); Files.writeString(gruss, "Hallo aus Java!\nZweite Zeile mit Umlauten: äöü ß\n"); String text = Files.readString(gruss); System.out.print(text);
// Zeilen als Liste schreiben und lesen Path einkauf = Path.of("daten", "einkauf.txt"); Files.write(einkauf, List.of("Milch", "Brot", "Äpfel")); Files.writeString(einkauf, "Käse" + System.lineSeparator(), StandardOpenOption.APPEND); // anhängen
List<String> zeilen = Files.readAllLines(einkauf); System.out.println(zeilen.size() + " Zeilen: " + zeilen); for (int i = 0; i < zeilen.size(); i++) { System.out.println((i + 1) + ". " + zeilen.get(i)); } }
}Hallo aus Java!Zweite Zeile mit Umlauten: äöü ß4 Zeilen: [Milch, Brot, Äpfel, Käse]1. Milch2. Brot3. Äpfel4. Käse| Methode | macht |
|---|---|
Files.writeString(pfad, text) |
schreibt einen Text in eine Datei – eine vorhandene wird überschrieben |
Files.readString(pfad) |
liest die ganze Datei als einen Text |
Files.write(pfad, zeilen) |
schreibt eine Liste von Texten, jeden in eine eigene Zeile |
Files.readAllLines(pfad) |
liest die Datei als List<String> – eine Zeile pro Element |
Files.createDirectories(pfad) |
legt einen Ordner an, auch mit allen Ordnern darüber – gibt es ihn schon, passiert nichts |
Mit StandardOpenOption.APPEND als letztem Argument hängt writeString an,
statt zu überschreiben.
throws IOException
Abschnitt betitelt „throws IOException“Lass testweise das throws IOException hinter main weg. IntelliJ unterstreicht
jeden Aufruf von Files rot: Unhandled exception: java.io.IOException.
Bei Dateien kann immer etwas schiefgehen: Die Datei fehlt, die Platte ist voll,
die Rechte reichen nicht. Deshalb ist die IOException eine geprüfte
Exception (siehe Exceptions): Der Compiler
besteht darauf, dass wir uns entscheiden – fangen oder weiterreichen. In den
Demos reichen wir sie mit throws aus main hinaus. Dann bricht das Programm
mit der Meldung ab. In einem echten Programm fangen wir sie und geben eine
verständliche Meldung aus.
Zeichensatz und Zeilenende
Abschnitt betitelt „Zeichensatz und Zeilenende“- Die Methoden von
Fileslesen und schreiben immer UTF-8. Deshalb kommen die Umlaute richtig an – auch wenn du die Datei mit dem Windows-Editor öffnest, der ebenfalls UTF-8 verwendet. Files.writebeendet jede Zeile mit dem Zeilenende des Betriebssystems: unter Windows zwei Zeichen,\r\n. Deshalb verwenden wir beim AnhängenSystem.lineSeparator()statt\n.
Wo sind die Dateien?
Abschnitt betitelt „Wo sind die Dateien?“Im Fenster Project von IntelliJ erscheint der Ordner daten im Projekt.
Taucht er nicht auf: Rechtsklick auf das Projekt → Reload from Disk. Mit
einem Doppelklick öffnest du eine Datei direkt in IntelliJ.
Nachsehen, kopieren, verschieben, löschen
Abschnitt betitelt „Nachsehen, kopieren, verschieben, löschen“package de.drv.dateien;
import java.io.IOException;import java.nio.file.Files;import java.nio.file.NoSuchFileException;import java.nio.file.Path;import java.nio.file.StandardCopyOption;
public class Dateiverwaltung {
public static void main(String[] args) throws IOException { Path einkauf = Path.of("daten", "einkauf.txt");
// Nachsehen System.out.println("gibt es? " + Files.exists(einkauf)); System.out.println("Datei? " + Files.isRegularFile(einkauf)); System.out.println("Ordner? " + Files.isDirectory(einkauf.getParent())); System.out.println("Größe: " + Files.size(einkauf) + " Bytes");
// Kopieren, verschieben, löschen Path sicherung = Path.of("daten", "sicherung", "einkauf.txt"); Files.createDirectories(sicherung.getParent()); Files.copy(einkauf, sicherung, StandardCopyOption.REPLACE_EXISTING); System.out.println("kopiert nach " + sicherung);
Path alt = Path.of("daten", "sicherung", "einkauf-alt.txt"); Files.move(sicherung, alt, StandardCopyOption.REPLACE_EXISTING); System.out.println("umbenannt in " + alt.getFileName());
Files.delete(alt); System.out.println("gelöscht – gibt es noch? " + Files.exists(alt));
// Was passiert, wenn es die Datei nicht gibt? try { Files.readString(Path.of("daten", "gibt-es-nicht.txt")); } catch (NoSuchFileException e) { System.out.println("nicht gefunden: " + e.getMessage()); } }
}gibt es? trueDatei? trueOrdner? trueGröße: 28 Byteskopiert nach daten\sicherung\einkauf.txtumbenannt in einkauf-alt.txtgelöscht – gibt es noch? falsenicht gefunden: daten\gibt-es-nicht.txt28 Bytes für vier kurze Wörter? Die Buchstaben ergeben 18 Bytes, jedes Ä und
ä braucht in UTF-8 aber zwei Bytes (+2), und jedes Zeilenende unter
Windows ebenfalls zwei (+8).
| Methode | macht | wenn etwas nicht passt |
|---|---|---|
Files.exists(pfad) |
gibt es die Datei oder den Ordner? | – |
Files.isRegularFile(pfad), isDirectory(pfad) |
ist es eine Datei, ein Ordner? | – |
Files.size(pfad) |
Größe in Bytes | NoSuchFileException |
Files.copy(von, nach) |
kopiert | FileAlreadyExistsException, wenn das Ziel schon existiert |
Files.move(von, nach) |
verschiebt oder benennt um | wie copy |
Files.delete(pfad) |
löscht | NoSuchFileException; bei einem Ordner mit Inhalt DirectoryNotEmptyException |
Files.deleteIfExists(pfad) |
löscht, wenn vorhanden | – |
Soll copy oder move ein vorhandenes Ziel überschreiben, gibst du
StandardCopyOption.REPLACE_EXISTING mit. Alle Exceptions in der rechten Spalte
sind Unterklassen der IOException – wer nur die IOException fängt, fängt sie
alle mit.
Übung: Mit Dateien arbeiten
Abschnitt betitelt „Übung: Mit Dateien arbeiten“Arbeite im Projekt 22-dateien. Jede Stufe ist ein eigenes kleines Programm.
-
Notizbuch: Das Programm
Notizbuchhängt seine Argumente als eine neue Zeile an die Dateidaten\notizen.txtan – mit Datum und Uhrzeit davor. Danach gibt es alle Notizen aus. Ohne Argumente zeigt es nur die Notizen, und solange es noch keine Datei gibt: Noch keine Notizen.Terminal-Fenster Notizen (2):20.10.2026 09:15 Milch kaufen20.10.2026 09:16 Java-Kapitel lesenTipp: Damit
APPENDauch eine neue Datei anlegt, gib zusätzlichStandardOpenOption.CREATEmit. Wie man Argumente zu einem Text zusammenfügt und ein Datum formatiert, kennst du aus Woche 1. -
Dateistatistik: Das Programm
Dateistatistikbekommt einen Dateinamen als Argument und zählt Zeilen, Wörter und Zeichen. Gibt es die Datei nicht, kommt eine verständliche Meldung – kein Stacktrace. Fange dafür dieNoSuchFileException. -
Sicherung: Das Programm
Sicherungkopiert eine Datei in den Ordnersicherungund hängt das heutige Datum an den Namen:notizen.txt→notizen-2026-10-20.txt. Den Ordner legt es bei Bedarf an. Gibt es die Sicherung von heute schon, überschreibt es sie nicht, sondern meldet das. -
Für Schnelle: Das Programm
Suchebekommt einen Suchbegriff und einen Dateinamen und gibt alle Zeilen aus, die den Begriff enthalten – mit Zeilennummer und egal ob groß oder klein geschrieben. Am Ende steht die Zahl der Treffer.Terminal-Fenster 1: Java ist eine Sprache.2: Java ist eine Plattform.2 Treffer
Lösung
Pfad und Datumsformat stehen als Konstanten oben in der Klasse – so sind sie an
einer Stelle änderbar. CREATE und APPEND zusammen heißen: „Lege die Datei
an, wenn es sie noch nicht gibt, und hänge sonst an.“
package de.drv.dateien;
import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.StandardOpenOption;import java.time.LocalDateTime;import java.time.format.DateTimeFormatter;import java.util.List;
/** Stufe 1: hängt die Argumente als Notiz an und zeigt alle Notizen. */public class Notizbuch {
private static final Path DATEI = Path.of("daten", "notizen.txt"); private static final DateTimeFormatter FORMAT = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm");
public static void main(String[] args) throws IOException { if (args.length > 0) { String notiz = LocalDateTime.now().format(FORMAT) + " " + String.join(" ", args); Files.createDirectories(DATEI.getParent()); Files.writeString(DATEI, notiz + System.lineSeparator(), StandardOpenOption.CREATE, StandardOpenOption.APPEND); }
if (!Files.exists(DATEI)) { System.out.println("Noch keine Notizen."); return; } List<String> notizen = Files.readAllLines(DATEI); System.out.println("Notizen (" + notizen.size() + "):"); for (String notiz : notizen) { System.out.println(" " + notiz); } }
}Lösung
Die Reihenfolge der catch-Blöcke ist wichtig: NoSuchFileException ist eine
Unterklasse von IOException und muss deshalb zuerst stehen. Wörter zählt
das Programm mit split("\\s+") – nach trim(), sonst zählte ein Leerzeichen
am Zeilenanfang als zusätzliches leeres Wort.
package de.drv.dateien;
import java.io.IOException;import java.nio.file.Files;import java.nio.file.NoSuchFileException;import java.nio.file.Path;import java.util.List;
/** Stufe 2: Zeilen, Wörter und Zeichen einer Datei – wie wc unter Linux. */public class Dateistatistik {
public static void main(String[] args) { if (args.length != 1) { System.out.println("Aufruf: Dateistatistik <Datei>"); return; } Path datei = Path.of(args[0]); try { List<String> zeilen = Files.readAllLines(datei); int woerter = 0; int zeichen = 0; for (String zeile : zeilen) { zeichen += zeile.length(); if (!zeile.isBlank()) { woerter += zeile.trim().split("\\s+").length; } } System.out.printf("%s: %d Zeilen, %d Wörter, %d Zeichen%n", datei.getFileName(), zeilen.size(), woerter, zeichen); } catch (NoSuchFileException e) { System.out.println("Die Datei gibt es nicht: " + datei.toAbsolutePath()); } catch (IOException e) { System.out.println("Die Datei lässt sich nicht lesen: " + e.getMessage()); } }
}Lösung
Den neuen Namen setzt das Programm aus drei Teilen zusammen: Name ohne Endung,
Datum, Endung. lastIndexOf('.') findet den letzten Punkt – so bleibt bei
bericht.2026.txt die Endung .txt. LocalDate.now() ergibt als Text schon
die Form 2026-10-20, die sich auch richtig sortieren lässt.
Files.copy ohne REPLACE_EXISTING würde bei einem vorhandenen Ziel ohnehin
eine FileAlreadyExistsException werfen. Die Prüfung vorher erlaubt eine
freundlichere Meldung.
package de.drv.dateien;
import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.time.LocalDate;
/** Stufe 3: kopiert eine Datei mit dem heutigen Datum im Namen in den Ordner sicherung. */public class Sicherung {
public static void main(String[] args) throws IOException { if (args.length != 1) { System.out.println("Aufruf: Sicherung <Datei>"); return; } Path quelle = Path.of(args[0]); if (!Files.isRegularFile(quelle)) { System.out.println("Keine Datei: " + quelle); return; }
// notizen.txt → notizen-2026-10-20.txt String name = quelle.getFileName().toString(); int punkt = name.lastIndexOf('.'); String neuerName = punkt < 0 ? name + "-" + LocalDate.now() : name.substring(0, punkt) + "-" + LocalDate.now() + name.substring(punkt);
Path ziel = Path.of("sicherung").resolve(neuerName); if (Files.exists(ziel)) { System.out.println("Heute schon gesichert: " + ziel); return; } Files.createDirectories(ziel.getParent()); Files.copy(quelle, ziel); System.out.println("Gesichert: " + ziel + " (" + Files.size(ziel) + " Bytes)"); }
}Lösung
package de.drv.dateien;
import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.util.List;
/** Stufe 4: alle Zeilen einer Datei, die einen Suchbegriff enthalten – wie findstr. */public class Suche {
public static void main(String[] args) throws IOException { if (args.length != 2) { System.out.println("Aufruf: Suche <Begriff> <Datei>"); return; } String begriff = args[0].toLowerCase(); List<String> zeilen = Files.readAllLines(Path.of(args[1]));
int treffer = 0; for (int i = 0; i < zeilen.size(); i++) { if (zeilen.get(i).toLowerCase().contains(begriff)) { System.out.printf("%4d: %s%n", i + 1, zeilen.get(i)); treffer++; } } System.out.println(treffer + " Treffer"); }
}