Zum Inhalt springen

Java I/O: Dateien, Streams, Reader und Writer im Überblick

Ein flacher Sortierkasten aus hellem Buchenholz auf Hellblau, von oben gesehen, mit zwölf Fächern in drei Reihen: eine Filmspule, eine Messinglupe, ein Nest Bandnudeln, ein Spritzbeutel, ein Papierkranich, vier bunte Holzwürfel, eine Messingwalze in einem warm leuchtenden Fach, eine leuchtende Lichterkette aus Kupferdraht, ein Leporello aus Papier, ein Handlocher, vier farbige Glasformen und eine blaue Glasfliese

Für Dateien bringt Java zwei APIs mit: das Package java.io aus Java 1.0 und das Package java.nio.file aus Java 7. Die meisten Aufgaben erledigst du mit der neuen API – mit einer einzigen Zeile aus der Klasse java.nio.file.Files.

Das folgende Programm schreibt einen String in eine Datei und liest ihn wieder ein:

Path file = Path.of("target/greeting.txt");
Files.writeString(file, "Grüße aus Java\n");
String text = Files.readString(file);
System.out.print(text);
Grüße aus Java

Files.writeString() legt die Datei an oder überschreibt sie und schreibt den String UTF-8-kodiert hinein. Files.readString() liest die Datei wieder ein. Beide Methoden öffnen und schließen die Datei selbst.

Sobald eine Datei nicht mehr in den Arbeitsspeicher passt, du sie Zeile für Zeile verarbeiten oder Binärdaten schreiben möchtest, brauchst du die Klassen, mit denen Java Daten Stück für Stück liest und schreibt: Streams, Reader und Writer.

Dieser Artikel ist die Landkarte der Serie über Dateien in Java. Er erklärt die Begriffe, die alle anderen Teile voraussetzen, und führt dich für jede Aufgabe zu dem Artikel, der sie im Detail zeigt.

In diesem Artikel erfährst du,

  • mit welchem Aufruf du die häufigsten Aufgaben rund um Dateien erledigst,
  • warum Java zwei Datei-APIs hat und welche du für neuen Code verwenden solltest,
  • worin sich Byte-Streams und Zeichen-Streams unterscheiden und wozu du Streams ineinander verschachtelst,
  • welche Klasse Text, Bytes, primitive Werte und Objekte liest und schreibt,
  • wie du Dateien und Verzeichnisse anlegst, kopierst, verschiebst und löschst,
  • wann du statt eines Streams einen FileChannel brauchst,
  • welche Exceptions beim Dateizugriff auftreten und wie du Dateien zuverlässig schließt,
  • welche Fehler die Artikel der Serie zeigen und wie du sie vermeidest.

Die Beispiele in diesem Artikel

Den vollständigen Code findest du im GitHub-Repository java-file-io, im Package eu.happycoders.overview. Jeder Abschnitt mit einem Beispiel hat dort eine eigene Klasse mit einer main()-Methode, die die gezeigten Ausgaben erzeugt.

Die Beispiele lesen die Datei files/server.log aus dem Repository, ein Server-Log mit fünf Zeilen, und schreiben in das Verzeichnis target. Die Ausgaben stammen von macOS; Meldungen des Betriebssystems lauten unter Windows anders.

Die Klassen im Repository brauchen Java 25, weil sie die vereinfachte main()-Methode ohne String[] args verwenden. Die Listings im Artikel laufen ab Java 11 – bis auf das Konsolenbeispiel mit der Klasse IO, das Java 25 voraussetzt.

Die häufigsten Aufgaben auf einen Blick

Die folgende Tabelle nennt für die häufigsten Aufgaben den Aufruf, der sie erledigt. path ist darin ein Path-Objekt, das auf eine Datei zeigt, dir ein Path-Objekt, das auf ein Verzeichnis zeigt, target ein Path-Objekt, das auf das Ziel einer Kopie zeigt, und APPEND ist die statisch importierte Konstante StandardOpenOption.APPEND. Der Link in der linken Spalte führt zu dem Artikel, der die Aufgabe ausführlich behandelt:

AufgabeAufruf
Textdatei in einen String lesenFiles.readString(path)
Textdatei in eine Liste von Zeilen lesenFiles.readAllLines(path)
Textdatei Zeile für Zeile verarbeitenFiles.lines(path)
Binärdatei in ein Byte-Array lesenFiles.readAllBytes(path)
String in eine Datei schreibenFiles.writeString(path, text)
Text an eine Datei anhängenFiles.writeString(path, text, APPEND)
Byte-Array in eine Datei schreibenFiles.write(path, bytes)
Prüfen, ob eine Datei existiertFiles.exists(path)
Verzeichnis samt Elternverzeichnissen anlegenFiles.createDirectories(dir)
Datei kopierenFiles.copy(path, target)
Datei verschieben oder umbenennenFiles.move(path, target)
Datei löschenFiles.delete(path)
Verzeichnis auslesenFiles.list(dir)
Arbeitsverzeichnis ermittelnPath.of("").toAbsolutePath()

Alle Aufrufe bis auf den letzten sind statische Methoden der Klasse Files. Die Klasse Ch1Tasks im Repository führt sie der Reihe nach aus.

Files.lines() und Files.list() unterscheiden sich von den übrigen Methoden: Sie liefern einen Stream, der die Datei bzw. das Verzeichnis so lange geöffnet hält, bis du ihn schließt. Wie das aussieht, zeigt der Abschnitt Dateien lesen.

Zwei APIs: java.io und java.nio.file

Die Klassen für Dateien stammen aus drei Ausbaustufen, und alle drei sind bis heute im JDK: java.io, NIO und NIO.2. Für Pfade und Dateioperationen gibt es dabei zwei APIs – File aus java.io und Path mit Files aus NIO.2. Welche du für neuen Code verwenden solltest, steht am Ende dieses Abschnitts.

Was wann dazukam

Die folgende Tabelle zeigt, welche Java-Version welche Klassen und Methoden für Dateien gebracht hat. NIO steht für „New I/O“, NIO.2 für die zweite Ausbaustufe davon:

VersionWas dazukam
Java 1.0java.io mit File, InputStream, OutputStream, FileInputStream, FileOutputStream und RandomAccessFile
Java 1.1Reader und Writer für Text, darunter InputStreamReader, BufferedReader, BufferedWriter und PrintWriter
Java 1.4NIO im Package java.nio: FileChannel und ByteBuffer
Java 7NIO.2 im Package java.nio.file: Path, Paths und Files
Java 8Files.lines(), Files.list() und Files.walk(), die einen Stream liefern, dazu UncheckedIOException
Java 11Files.readString(), Files.writeString() und Path.of()
Java 18UTF-8 als Standardkodierung aller APIs, denen du keinen Charset übergibst (JEP 400)
Java 25die Klasse java.lang.IO für Ein- und Ausgaben auf der Konsole

Die folgende Grafik zeigt die drei Packages java.io, java.nio.file und java.nio mit ihren wichtigsten Typen und wie sie zusammenhängen. java.nio.file steht in der Mitte, weil es die beiden anderen verbindet: Path lässt sich in ein File umwandeln und zurück, Files liefert die Streams und Reader aus java.io, und FileChannel.open() öffnet einen Channel zu einem Path. Dunkelblau umrandet ist die API, die ich dir für neuen Code empfehle, hellblau umrandet sind die Klassen, die weiterhin aktuell sind, und grau umrandet ist File, das mit Path einen Nachfolger hat:

Die Packages java.io, java.nio.file und java.nio mit File, InputStream, OutputStream, Reader, Writer, Path, Files, FileChannel und ByteBuffer und den Methoden, die sie verbinden

File und Path

Bis Java 7 war java.io.File die einzige Klasse, die Dateien und Verzeichnisse darstellt. Ihr Name führt gerade Einsteiger:innen in die Irre, denn er lässt vermuten, dass sie nur Dateien darstellt.

NIO.2 teilt diese Aufgabe auf: Das Interface java.nio.file.Path beschreibt nur noch den Pfad, und die Klasse Files führt mit ihren statischen Methoden alle Operationen darauf aus – Lesen, Schreiben, Anlegen, Kopieren, Löschen.

Der wichtigste Unterschied für deinen Code liegt in der Fehlerbehandlung. Das folgende Programm versucht, eine Datei zu löschen, die es nicht gibt, und ein Verzeichnis auszulesen, das in Wirklichkeit eine Datei ist – einmal mit File, einmal mit Files:

File file = new File("target/missing.txt");
boolean deleted = file.delete();
System.out.println("deleted = " + deleted);

Path path = Path.of("target/missing.txt");
try {
  Files.delete(path);
} catch (IOException e) {
  System.out.println(e);
}

File[] children = new File("files/server.log").listFiles();
System.out.println("children = " + children);

try (Stream<Path> entries = Files.list(Path.of("files/server.log"))) {
  System.out.println(entries.count());
} catch (IOException e) {
  System.out.println(e);
}
deleted = false
java.nio.file.NoSuchFileException: target/missing.txt
children = null
java.nio.file.NotDirectoryException: files/server.log

File.delete() meldet den Fehlschlag nur mit false, File.listFiles() nur mit null. Warum es nicht geklappt hat, erfährst du nicht – und wer den Rückgabewert nicht prüft, merkt nicht einmal, dass es nicht geklappt hat. Files wirft stattdessen eine Exception, deren Typ den Grund nennt: NoSuchFileException für die fehlende Datei, NotDirectoryException für die Datei, die kein Verzeichnis ist.

Dazu kann Files, was File nicht kann: symbolische Links anlegen (Files.createSymbolicLink()), den Eigentümer und die POSIX-Rechte einer Datei lesen (Files.getOwner() und Files.getPosixFilePermissions()) und eine Datei atomar verschieben (Files.move() mit der Option ATOMIC_MOVE). Die Methode File.renameTo() dagegen kann laut Javadoc je nach Betriebssystem nicht zwischen Dateisystemen verschieben, nicht atomar arbeiten und an einer vorhandenen Zieldatei scheitern.

Zwischen beiden Welten wechselst du mit file.toPath() und path.toFile().

Welche API solltest du verwenden?

Ich empfehle dir für neuen Code: Path für Pfade und Files für alle Operationen auf Dateien und Verzeichnissen. Ein File erzeugst du nur noch mit path.toFile(), wenn eine ältere API eines verlangt.

Allerdings wirft fast jede Methode von Files eine checked IOException, die du behandeln oder weiterreichen musst – auch dort, wo File einfach false zurückgegeben hätte.

Veraltet sind die Klassen aus java.io damit nicht. Auch NIO.2 liest und schreibt über InputStream, Reader und ihre Verwandten: Files.newInputStream() liefert einen InputStream, Files.newBufferedReader() einen BufferedReader. Nur File hat mit Path einen Nachfolger.

Weitere Unterschiede zwischen beiden APIs zeigt der Artikel über das Erstellen, Kopieren, Verschieben und Löschen von Dateien.

Das Stream-Modell: Bytes und Zeichen

In java.io fließen Daten als sogenannter Stream (Datenstrom): eine Folge von Werten, die du von vorn nach hinten liest oder schreibst. Java unterscheidet zwei Arten von Streams, je nachdem, was die Werte sind – Bytes oder Zeichen.

Byte-Streams: InputStream und OutputStream

Die abstrakte Klasse InputStream liest Bytes. Ihre Methode read() liefert das nächste Byte als int zwischen 0 und 255 – oder -1, wenn der Stream zu Ende ist. Das Gegenstück OutputStream schreibt Bytes mit write().

Was die Bytes bedeuten, spielt für einen Byte-Stream keine Rolle. Er transportiert ein Bild genauso wie eine Textdatei.

Zeichen-Streams: Reader und Writer

Die abstrakte Klasse Reader liest Zeichen. Ihre Methode read() liefert das nächste Zeichen als int zwischen 0 und 65.535 – oder -1 am Ende. Das Gegenstück Writer schreibt Zeichen.

Zwischen Bytes und Zeichen steht die Zeichenkodierung (Charset): Sie legt fest, welche Bytes welches Zeichen darstellen. In UTF-8 belegt ein „G“ ein Byte, ein „ü“ zwei.

Das folgende Programm schreibt das Wort „Grüße“ in eine Datei und liest es zweimal: mit einem FileInputStream als Bytes und mit einem FileReader als Zeichen. Beide geben jeden gelesenen Wert als Zahl aus:

Files.writeString(Path.of("target/greeting.txt"), "Grüße\n");

try (InputStream in = new FileInputStream("target/greeting.txt")) {
  int b;
  while ((b = in.read()) != -1) {
    System.out.print(b + " ");
  }
}
System.out.println();

try (Reader reader = new FileReader("target/greeting.txt", UTF_8)) {
  int c;
  while ((c = reader.read()) != -1) {
    System.out.print(c + " ");
  }
}
System.out.println();
71 114 195 188 195 159 101 10 
71 114 252 223 101 10 

Der FileInputStream liest acht Werte, der FileReader sechs. „G“ (71), „r“ (114), „e“ (101) und der Zeilenumbruch (10) sind in beiden Zeilen gleich. Das „ü“ dagegen steht in der Datei als die zwei Bytes 195 und 188, und der FileReader dekodiert sie zum Zeichen 252 – dem Unicode-Wert von „ü“. Ebenso wird aus 195 und 159 das „ß“ mit dem Wert 223.

Liest du Text mit einer anderen Kodierung, als mit der er geschrieben wurde, bekommst du falsche Zeichen. Deshalb übergibt das Beispiel den Charset UTF_8 explizit. Ohne ihn verwendet FileReader die Standardkodierung der JVM, und die ist erst seit Java 18 überall UTF-8.

Streams ineinander verschachteln

Viele Klassen in java.io lesen nicht selbst aus einer Datei, sondern aus einem anderen Stream, den du ihrem Konstruktor übergibst. Jede dieser Klassen fügt dabei eine Fähigkeit hinzu:

  • InputStreamReader dekodiert die Bytes eines InputStream mit einem Charset zu Zeichen.
  • BufferedReader liest in großen Blöcken in einen Puffer und liefert ganze Zeilen.
  • DataInputStream setzt Bytes zu primitiven Werten wie int und double zusammen.
  • ObjectInputStream stellt Objekte wieder her, die ein ObjectOutputStream geschrieben hat.

Auf der Schreibseite heißen die Gegenstücke OutputStreamWriter, BufferedWriter, DataOutputStream und ObjectOutputStream. Dazu kommt PrintWriter, der Text mit println() und printf() formatiert.

Das folgende Programm verschachtelt drei Streams ineinander, um die Datei target/greeting.txt aus dem vorigen Beispiel zeilenweise als Text zu lesen:

try (BufferedReader reader =
    new BufferedReader(
        new InputStreamReader(
            new FileInputStream("target/greeting.txt"), UTF_8))) {
  System.out.println(reader.readLine());
}
Grüße

Der FileInputStream liest die Bytes aus der Datei, der InputStreamReader dekodiert sie zu Zeichen, und der BufferedReader puffert die Zeichen und liefert mit readLine() die erste Zeile. Schließt du den äußeren BufferedReader, schließt er den InputStreamReader und den FileInputStream mit.

Die folgende Grafik zeigt diese Kette zusammen mit den anderen Wegen, eine Datei zu lesen: binär oder als Text, jeweils ungepuffert oder gepuffert. Durchgezogene Linien führen zu Binärdaten, gestrichelte zu Textdaten. BufferedInputStream puffert die Bytes, ohne sie zu dekodieren, und FileReader – im gestrichelten Rahmen – fasst FileInputStream und InputStreamReader in einer Klasse zusammen:

Übersicht Java-Klassen: FileInputStream, FileReader, InputStreamReader, BufferedInputStream, BufferedReader

Diese Kette musst du selten selbst bauen. Files.newBufferedReader() erzeugt sie für dich, mit UTF-8 als Kodierung, wenn du keine angibst. Anders als die selbst gebaute Kette wirft der so erzeugte BufferedReader eine MalformedInputException, wenn die Datei Bytes enthält, die nicht zur Kodierung passen, statt sie durch „�“ zu ersetzen.

Die Klassen im Überblick

Die folgenden zwei Tabellen ordnen die Klassen der Byte- und der Zeichen-Streams nach ihrer Rolle. Jeder Klassenname führt zu dem Artikel oder Abschnitt der Serie, der die Klasse behandelt. Die erste Tabelle zeigt die Byte-Streams:

RolleLesenSchreiben
BasisklasseInputStreamOutputStream
DateiFileInputStreamFileOutputStream
PufferBufferedInputStreamBufferedOutputStream
Primitive WerteDataInputStreamDataOutputStream
ObjekteObjectInputStreamObjectOutputStream
Formatierter Text✗PrintStream

PrintStream steht bei den Byte-Streams, obwohl er Text schreibt: Er kodiert den Text selbst zu Bytes. Auch System.out ist ein PrintStream.

Die zweite Tabelle zeigt die Zeichen-Streams:

RolleLesenSchreiben
BasisklasseReaderWriter
DateiFileReaderFileWriter
PufferBufferedReaderBufferedWriter
Brücke zu den Byte-StreamsInputStreamReaderOutputStreamWriter
Formatierter Text✗PrintWriter

Dateien lesen

Eine Textdatei kannst du auf drei Wegen lesen. Welcher passt, hängt davon ab, wie groß die Datei ist und wie du sie verarbeitest:

  • Auf einmal: Files.readString() liefert den Inhalt als String, Files.readAllLines() als Liste von Zeilen. Beide Methoden halten die ganze Datei im Arbeitsspeicher.
  • Zeile für Zeile als Stream: Files.lines() liest die Zeilen erst in den Arbeitsspeicher, während der Stream sie verarbeitet. So kannst du auch Dateien verarbeiten, die größer sind als dein Heap.
  • Zeile für Zeile in einer Schleife: BufferedReader.readLine() liefert bei jedem Aufruf die nächste Zeile. Auch dabei kommt die Datei nach und nach in den Arbeitsspeicher: Der BufferedReader liest sie in Blöcken von 8.192 Zeichen und hält nur einen Block und die aktuelle Zeile im Speicher. Diesen Weg nimmst du, wenn dir eine Schleife lieber ist als ein Stream oder wenn der Text nicht aus einer Datei kommt, sondern aus einem beliebigen Reader – etwa von der Konsole oder aus dem Netzwerk.

Für Binärdateien gibt es dieselbe Unterscheidung: Files.readAllBytes() liest die ganze Datei in ein Byte-Array, Files.newInputStream() liefert einen InputStream, aus dem du sie in Blöcken liest.

Das folgende Programm zählt mit Files.lines(), wie viele Zeilen der Datei files/server.log auf jeden Log-Level entfallen. Weil Files.lines() die Zeilen nach und nach liest, ginge das genauso mit einer Datei von vielen hundert Gigabyte. Das Level steht in jeder Zeile ab dem 21. Zeichen und ist höchstens fünf Zeichen lang:

Path log = Path.of("files/server.log");
try (Stream<String> lines = Files.lines(log)) {
  Map<String, Long> levels = lines
      .map(line -> line.substring(20, 25).strip())
      .collect(groupingBy(level -> level, TreeMap::new, counting()));
  System.out.println(levels);
}
{ERROR=1, INFO=3, WARN=1}

map() schneidet aus jeder Zeile das Level aus, und der Collector groupingBy() – wie counting() statisch aus Collectors importiert – zählt die Zeilen pro Level in einer sortierten TreeMap.

Auf das try-with-resources-Statement um den Stream darfst du nicht verzichten. Files.lines() öffnet die Datei, und erst close() schließt sie wieder. Ohne close() bliebe sie geöffnet, und bei vielen Aufrufen gehen dem Prozess die Datei-Deskriptoren aus, sodass jeder weitere Versuch, eine Datei zu öffnen, mit einer FileSystemException („Too many open files“) scheitert.

Alle Wege mit ihren Kodierungen und einer Laufzeitmessung zeigt der Artikel Datei einlesen in Java. Die Artikel über den FileReader und den BufferedReader gehen auf diese beiden Klassen im Detail ein.

Dateien schreiben

Auch zum Schreiben einer Datei gibt es drei Wege:

  • Auf einmal: Files.writeString() schreibt einen String, Files.write() eine Liste von Zeilen oder ein Byte-Array.
  • Zeile für Zeile: Files.newBufferedWriter() liefert einen BufferedWriter, in den du mit write() und newLine() schreibst. Brauchst du formatierte Ausgaben mit printf(), verschachtelst du ihn in einem PrintWriter.
  • Binärdaten in Blöcken: Files.newOutputStream() liefert einen OutputStream, in den du mit write() einzelne Bytes oder ganze Byte-Arrays schreibst.

Ohne weitere Option legen alle diese Methoden die Datei an, wenn es sie noch nicht gibt, und überschreiben sie, wenn es sie gibt. Mit StandardOpenOption.APPEND hängen sie an eine vorhandene Datei an.

Das folgende Programm schreibt die Zeilenzahl pro Log-Level aus dem vorigen Abschnitt in eine Datei – das Level linksbündig in fünf Zeichen Breite, dahinter die Anzahl:

Map<String, Long> levels =
    new TreeMap<>(Map.of("ERROR", 1L, "INFO", 3L, "WARN", 1L));

Path report = Path.of("target/report.txt");
try (PrintWriter writer = new PrintWriter(Files.newBufferedWriter(report))) {
  levels.forEach((level, count) -> writer.printf("%-5s %d%n", level, count));
}
System.out.print(Files.readString(report));
ERROR 1
INFO  3
WARN  1

PrintWriter hat keinen Konstruktor, der einen Path annimmt. Deshalb verschachtelt das Beispiel den BufferedWriter aus Files.newBufferedWriter() in einem PrintWriter.

PrintWriter wirft keine IOException. Ob ein Schreibvorgang gescheitert ist, erfährst du nur über seine Methode checkError().

Alle Wege mit einer Laufzeitmessung zeigt der Artikel Datei schreiben in Java. Die Artikel über den FileWriter und den PrintWriter gehen auf diese beiden Klassen im Detail ein.

Pfade, Dateien und Verzeichnisse

Ein Path beschreibt den Weg zu einer Datei oder einem Verzeichnis – absolut wie /var/log/system.log oder relativ wie files/server.log. Einen relativen Pfad löst Java gegen das Arbeitsverzeichnis des Prozesses auf.

Pfade setzt du mit Path.of() und resolve() zusammen, nicht durch String-Verkettung. Beide Methoden setzen das Trennzeichen des Betriebssystems ein – / unter Linux und macOS, \ unter Windows. Wie das geht und worin sich absolute, relative und kanonische Pfade unterscheiden, zeigt der Artikel über Datei- und Verzeichnisnamen in Java.

Alle Operationen auf Dateien und Verzeichnissen erledigen statische Methoden der Klasse Files. Die folgende Tabelle ordnet sie den Aufgaben zu; der Link in der linken Spalte führt zum Abschnitt, der die Methoden zeigt:

AufgabeMethoden von Files
Existenz prüfenexists(), notExists()
Datei anlegencreateFile()
Verzeichnis anlegencreateDirectory(), createDirectories()
Temporäre Datei anlegencreateTempFile(), createTempDirectory()
Kopierencopy()
Verschieben und umbenennenmove()
Löschendelete(), deleteIfExists()
Verzeichnis auslesenlist(), newDirectoryStream()
Verzeichnisbaum durchsuchenwalk(), walkFileTree(), find()

Ein Verzeichnis, das noch Einträge enthält, löscht Files.delete() nicht; stattdessen wirft es eine DirectoryNotEmptyException. Wie du ein Verzeichnis samt Inhalt löschst oder kopierst, zeigt der Artikel über das Erstellen, Kopieren, Verschieben und Löschen von Dateien.

Binäre und strukturierte Daten

Für Daten, die kein Text sind, hat java.io zwei Paare von Streams:

  • DataOutputStream und DataInputStream schreiben und lesen primitive Werte und Strings in einem festen Binärformat. Lesen musst du in derselben Reihenfolge, in der du geschrieben hast – die Datei selbst sagt nicht, welcher Wert ein int ist und welcher ein double. Wie das aussieht, zeigt der Artikel über DataOutputStream und DataInputStream.
  • ObjectOutputStream und ObjectInputStream schreiben und lesen ganze Objekte samt der Objekte, auf die sie verweisen. Diese Serialisierung funktioniert für Klassen, die das Interface Serializable implementieren.

Serialisierte Daten aus einer Quelle, der du nicht vertraust, solltest du allerdings nie ungefiltert lesen. Denn welche Klassen deine Anwendung beim Lesen instanziiert, bestimmen die Daten. Infrage kommt jede serialisierbare Klasse auf dem Classpath, und viele davon führen dabei Code aus – Code, den Angreifer:innen mit präparierten Daten für ihre Zwecke nutzen können. Wie Deserialisierungsfilter das seit Java 9 begrenzen, zeigt der Artikel über die Serialisierung in Java.

Random Access, Channels und Memory-Mapped Files

Ein Stream liest und schreibt von vorn nach hinten. Willst du hingegen an eine bestimmte Stelle einer Datei springen, brauchst du eine der folgenden zwei Klassen:

  • FileChannel (seit Java 1.4) liest und schreibt an beliebigen Positionen. Er arbeitet nicht mit einzelnen Bytes, sondern mit einem ByteBuffer. Mit map() blendet er eine Datei in den Arbeitsspeicher ein – ein sogenanntes Memory-Mapped File –, und mit lock() sperrt er eine Datei oder einen Teil davon gegen andere Prozesse.
  • RandomAccessFile (seit Java 1.0) springt mit seek() an eine Position und liest oder schreibt dort Bytes und primitive Werte.

Für neuen Code nimmst du den FileChannel: Du öffnest ihn mit FileChannel.open() direkt über einen Path, und nur er kann Dateien einblenden und sperren. RandomAccessFile nimmt nur einen Dateinamen als String oder ein File an. Die Klasse lohnt sich dort, wo du an wenigen Stellen einzelne primitive Werte lesen oder schreiben willst und dir der Umweg über einen ByteBuffer zu aufwendig ist.

Wie du mit einem FileChannel liest, schreibst, Dateien einblendest und sperrst, zeigt der Artikel über FileChannel, Memory-Mapped I/O und File Locks. Wie ein ByteBuffer mit position, limit, flip() und compact() arbeitet, erklärt der Artikel über den ByteBuffer.

Dateien schließen und IOException behandeln

Jede Datei, die dein Programm öffnet, belegt einen Datei-Deskriptor des Betriebssystems, bis das Programm sie wieder schließt. Die Zahl der Deskriptoren pro Prozess ist begrenzt.

Methoden wie Files.readString() und Files.writeString() schließen die Datei selbst. Gibt dir eine Methode dagegen ein Objekt zurück, das eine Datei oder ein Verzeichnis offen hält, musst du dieses Objekt selbst schließen: jeden InputStream, OutputStream, Reader und Writer sowie jeden Stream aus Files.lines(), Files.list() und Files.walk(). Der übliche Weg ist das try-with-resources-Statement (seit Java 7) – es schließt die Ressource auch dann, wenn eine Exception auftritt.

Fast jede Operation auf Dateien kann eine IOException werfen. Die Methoden aus Files werfen dabei Unterklassen, deren Namen den Grund nennen:

  • NoSuchFileException, wenn die Datei oder ein Verzeichnis auf dem Pfad nicht existiert,
  • AccessDeniedException, wenn die Rechte nicht reichen,
  • FileAlreadyExistsException, wenn eine anzulegende Datei schon existiert,
  • NotDirectoryException und DirectoryNotEmptyException für Verzeichnisse.

Alle diese Exceptions sind Unterklassen von FileSystemException. Anders als die Methoden aus Files werfen die Streams, Reader und Writer aus java.io sowohl für eine fehlende Datei als auch für fehlende Rechte dieselbe FileNotFoundException; nur ihre Nachricht nennt den Grund.

Das folgende Programm liest eine Datei, die es nicht gibt, ein Verzeichnis statt einer Datei und eine Datei, die in ISO-8859-1 statt in UTF-8 kodiert ist:

try {
  Files.readString(Path.of("files/missing.log"));
} catch (IOException e) {
  System.out.println(e);
}

try {
  Files.readString(Path.of("files"));
} catch (IOException e) {
  System.out.println(e);
}

Path latin1 = Path.of("target/latin1.txt");
Files.writeString(latin1, "line 1\nGrüße\nline 3\n", ISO_8859_1);
try (Stream<String> lines = Files.lines(latin1)) {
  lines.forEach(System.out::println);
} catch (UncheckedIOException e) {
  System.out.println(e);
}
java.nio.file.NoSuchFileException: files/missing.log
java.io.IOException: Is a directory
java.io.UncheckedIOException: java.nio.charset.MalformedInputException: Input length = 1

Für die fehlende Datei wirft Files.readString() eine NoSuchFileException. Für das Verzeichnis gibt es keine eigene Unterklasse; hier wirft die Methode eine einfache IOException mit der Nachricht des Betriebssystems.

Der dritte Fehler entsteht erst, während der Stream die Zeilen liest – in forEach(). Die Methoden eines Streams deklarieren keine checked Exceptions, deshalb verpackt Files.lines() die IOException in eine UncheckedIOException. Auslöser ist das „ü“. ISO-8859-1 speichert es als einzelnes Byte mit dem Wert 252. Files.lines() liest ohne Charset aber UTF-8, und in UTF-8 ist dieses Byte kein gültiges Zeichen.

Nicht nur Dateien: Konsole und andere Quellen

Die Abstraktionen aus java.io gelten nicht nur für Dateien. System.in ist ein InputStream, System.out ein PrintStream, und ein Socket liefert seine Daten über getInputStream() und getOutputStream(). Ein ByteArrayInputStream liest aus einem Byte-Array, ein StringReader aus einem String.

Schreibst du eine Methode so, dass sie einen Reader oder InputStream annimmt statt eines Path, funktioniert sie mit all diesen Quellen. In einem Unit-Test kannst du ihr dann z. B. einen StringReader übergeben statt einer Datei.

Nicht zu verwechseln mit dem Package java.io ist die Klasse java.lang.IO, die es seit Java 25 gibt. Sie gibt mit println() auf der Konsole aus und liest mit readln() eine Zeile ein. Weil sie im Package java.lang liegt, brauchst du keinen Import.

Das folgende Programm fragt nach einem Namen und gibt einen Gruß mit diesem Namen aus:

void main() {
  String name = IO.readln("Name: ");
  IO.println("Hallo, " + name + "!");
}
Name: Sven
Hallo, Sven!

Mit der vereinfachten main()-Methode aus Java 25 kommt dieses Programm ohne Klassendeklaration aus.

Häufige Fehler

Die folgenden Fehler kommen beim Arbeiten mit Dateien häufig vor. Der Link am Ende jedes Punkts führt zu den Details:

  • Pfade per String-Verkettung zusammensetzen: Ein fest eingebautes / oder \ passt nur zu einem Betriebssystem. Nutze stattdessen Path.of() und resolve() – die setzen automatisch das richtige Trennzeichen ein (Datei- und Verzeichnisnamen in Java).
  • Die Zeichenkodierung dem Standard überlassen: Bis einschließlich Java 17 hing die Standardkodierung von Betriebssystem und Spracheinstellung ab, unter einem deutschen Windows war sie meist Windows-1252. Erst seit Java 18 ist sie überall UTF-8. Kann dein Code auf einer älteren Version laufen, gib den Charset deshalb immer explizit an (Datei einlesen in Java).
  • Den Stream aus Files.lines(), Files.list() oder Files.walk() nicht schließen: Jeder dieser Streams hält eine Datei oder ein Verzeichnis geöffnet, und ohne close() gehen dem Prozess irgendwann die Datei-Deskriptoren aus. Öffne den Stream deshalb in einem try-with-resources-Statement – es schließt den Stream automatisch, auch wenn eine Exception auftritt (Verzeichnis auslesen).
  • Einen Writer nicht schließen: Was noch in seinem Puffer steht, kommt so nie in der Datei an. Öffne auch den Writer in einem try-with-resources-Statement – beim Schließen schreibt er seinen Puffer in die Datei (FileWriter).
  • Eine große Datei mit Files.readString() oder Files.readAllLines() lesen: Beide Methoden halten die ganze Datei im Heap. Files.lines() oder ein BufferedReader hingegen lesen sie zeilenweise (Datei einlesen in Java).
  • Den Rückgabewert von File.delete() oder File.mkdir() ignorieren: Beide melden einen Fehlschlag nur mit false. Die neueren Methoden Files.delete() und Files.createDirectory() hingegen werfen eine Exception mit dem Grund (File und Path).
  • Serialisierte Daten aus fremden Quellen ungefiltert lesen: Mit präparierten Daten können Angreifer:innen beim Lesen Code auf deinem Server ausführen. Ein Deserialisierungsfilter legt fest, welche Klassen entstehen dürfen (Serialisierung in Java).

Zusammenfassung

Java hat zwei APIs für Dateien: java.io aus Java 1.0 und NIO.2 im Package java.nio.file aus Java 7. Für neuen Code empfehle ich dir Path für Pfade und die statischen Methoden von Files für alle Operationen. Im Unterschied zu java.io.File melden sie Fehler mit einer Exception, deren Typ den Grund nennt.

Die Streams aus java.io sind dabei nicht veraltet – auch NIO.2 liest und schreibt über sie, etwa mit Files.newInputStream() oder Files.newBufferedReader(). Das Stream-Modell besteht aus drei Teilen:

  • Byte-Streams (InputStream und OutputStream) transportieren Bytes, ohne sie zu deuten.
  • Zeichen-Streams (Reader und Writer) transportieren Text. Zwischen Bytes und Text steht die Zeichenkodierung, und die solltest du immer angeben, wo dein Code auf Java 17 oder älter laufen kann. Erst seit Java 18 ist sie standardmäßig UTF-8.
  • Verschachtelte Streams fügen dem inneren Stream Fähigkeiten hinzu: Puffer, Zeilen, primitive Werte, Objekte, formatierten Text.

Kleine Dateien liest und schreibst du mit einer Zeile, etwa mit Files.readString() und Files.writeString(). Große Dateien verarbeitest du zeilenweise mit Files.lines() oder einem BufferedReader und schreibst sie mit einem BufferedWriter oder PrintWriter. Jeden Stream, Reader und Writer schließt du mit try-with-resources.

Wo du weiterliest, hängt von deiner Aufgabe ab:

Wenn dir der Artikel weitergeholfen hat, würde ich mich sehr über eine positive Bewertung auf meinem ProvenExpert-Profil freuen. Dein Feedback hilft mir, meine Inhalte weiter zu verbessern und motiviert mich, neue informative Artikel zu schreiben.

👉 Bewertung abgeben

Lust auf noch mehr Wissen?

In meinem Blog findest du viele Artikel zu Java, Softwarearchitektur und Performance von grundlegenden Konzepten bis hin zu fortgeschrittenen Patterns.

Wenn du tiefer einsteigen willst, schau dir meine Trainings an: praxisnah, verständlich und direkt auf euren Projektalltag übertragbar. Statt Theorie vermittle ich Prinzipien, die euch helfen, Code langfristig besser, wartbarer und performanter zu schreiben.

Zu den Java-Schulungen

Werde ein:e bessere:r Java-Entwickler:in

Mit meinem kostenlosen Newsletter bleibst du vorn. Modernes Java: neue Versionen & Features, Performance und JVM-Insights – 1x im Monat.

Suche