Zum Inhalt springen

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.

  • 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 IOException umgehen, die bei Dateien immer droht

Demo-Code: 22-dateien

⤓ demo-dateien.zip herunterladen

Der 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 /.

Pfade.java
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);
}
}
Terminal-Fenster
Pfad: daten\notizen.txt
Dateiname: notizen.txt
Ordner: daten
absolut: C:\dev\intellij\22-dateien\daten\notizen.txt
archiv: daten\archiv\2026.txt
  • Relative Pfade wie daten\notizen.txt gelten 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.
  • resolve hä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.

Für kleine Dateien – Notizen, Einstellungen, Listen – bietet Files Methoden, die eine Datei auf einmal lesen oder schreiben:

DateiDemo.java
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));
}
}
}
Terminal-Fenster
Hallo aus Java!
Zweite Zeile mit Umlauten: äöü ß
4 Zeilen: [Milch, Brot, Äpfel, Käse]
1. Milch
2. Brot
3. Äpfel
4. 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.

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.

  • Die Methoden von Files lesen 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.write beendet jede Zeile mit dem Zeilenende des Betriebssystems: unter Windows zwei Zeichen, \r\n. Deshalb verwenden wir beim Anhängen System.lineSeparator() statt \n.

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.

Dateiverwaltung.java
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());
}
}
}
Terminal-Fenster
gibt es? true
Datei? true
Ordner? true
Größe: 28 Bytes
kopiert nach daten\sicherung\einkauf.txt
umbenannt in einkauf-alt.txt
gelöscht – gibt es noch? false
nicht gefunden: daten\gibt-es-nicht.txt

28 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.

Arbeite im Projekt 22-dateien. Jede Stufe ist ein eigenes kleines Programm.

  1. Notizbuch: Das Programm Notizbuch hängt seine Argumente als eine neue Zeile an die Datei daten\notizen.txt an – 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 kaufen
    20.10.2026 09:16 Java-Kapitel lesen

    Tipp: Damit APPEND auch eine neue Datei anlegt, gib zusätzlich StandardOpenOption.CREATE mit. Wie man Argumente zu einem Text zusammenfügt und ein Datum formatiert, kennst du aus Woche 1.

  2. Dateistatistik: Das Programm Dateistatistik bekommt 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 die NoSuchFileException.

  3. Sicherung: Das Programm Sicherung kopiert eine Datei in den Ordner sicherung und 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.

  4. Für Schnelle: Das Programm Suche bekommt 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.“

Notizbuch.java
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.

Dateistatistik.java
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.

Sicherung.java
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
Suche.java
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");
}
}