0Pricing
Java Academy · Lektion

Files-Utility: Lesen, Schreiben, Kopieren, Verschieben

Verwenden Sie Files.readString, writeString, copy, move und delete für gängige Dateioperationen.

Files-Utility: Lesen, Schreiben, Kopieren, Verschieben ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Die Files-Klasse

Die Klasse java.nio.file.Files stellt statische Hilfsmethoden zum Lesen, Schreiben, Kopieren, Verschieben und Abfragen von Dateien bereit. Sie ersetzt den ausführlichen Boilerplate-Code von FileInputStream/FileOutputStream.

import java.nio.file.*;
import java.io.IOException;

Path file = Path.of("example.txt");
// All Files methods throw IOException — handle or propagate

Dateien lesen

Moderne Methoden zum Lesen des gesamten Inhalts einer Datei:

Path path = Path.of("notes.txt");

// Read as a single String (Java 11+)
String content = Files.readString(path);
System.out.println(content);

// Read as List of lines
List<String> lines = Files.readAllLines(path);
lines.forEach(System.out::println);

// Read as byte array
byte[] bytes = Files.readAllBytes(path);

Dateien schreiben

Schreiben Sie eine Zeichenkette oder eine Sammlung von Zeilen mit einem einzigen Aufruf in eine Datei:

Path out = Path.of("output.txt");

// Write a String (overwrites by default)
Files.writeString(out, "Hello, NIO.2!");

// Write with StandardOpenOption.APPEND
Files.writeString(out, "\nAppended line", StandardOpenOption.APPEND);

// Write lines
List<String> lines = List.of("line1", "line2", "line3");
Files.write(out, lines);

Dateieigenschaften prüfen

Fragen Sie Dateimetadaten ab, ohne die Datei zu öffnen:

Path path = Path.of("data.txt");

System.out.println(Files.exists(path));       // true/false
System.out.println(Files.isRegularFile(path)); // true if not dir
System.out.println(Files.isDirectory(path));   // true if dir
System.out.println(Files.isReadable(path));    // readable?
System.out.println(Files.size(path));          // bytes
System.out.println(Files.getLastModifiedTime(path));

Dateien kopieren

Files.copy(source, target) kopiert eine Datei. Verwenden Sie StandardCopyOption, um das Verhalten zu steuern:

Path src = Path.of("original.txt");
Path dst = Path.of("backup.txt");

// Throws if destination exists (default)
Files.copy(src, dst);

// Overwrite if exists:
Files.copy(src, dst, StandardCopyOption.REPLACE_EXISTING);

// Copy preserving file timestamps:
Files.copy(src, dst, StandardCopyOption.COPY_ATTRIBUTES);

Dateien verschieben und umbenennen

Files.move() verschiebt eine Datei oder benennt sie um. Mit ATOMIC_MOVE ist ein atomarer Verschiebevorgang möglich:

Path from = Path.of("temp.txt");
Path to   = Path.of("archive/report_2024.txt");

Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);

// Rename in same directory:
Path renamed = from.resolveSibling("new_name.txt");
Files.move(from, renamed, StandardCopyOption.REPLACE_EXISTING);

Dateien löschen

Zwei Löschmethoden — eine löst eine Ausnahme aus, wenn die Datei nicht gefunden wird, die andere nicht:

Path file = Path.of("temp.txt");

// Throws NoSuchFileException if file doesn't exist:
Files.delete(file);

// Returns false if file didn't exist (no exception):
boolean deleted = Files.deleteIfExists(file);
System.out.println("Deleted: " + deleted);

Verzeichnisse erstellen

Erstellen Sie Verzeichnisse einschließlich aller erforderlichen Zwischenverzeichnisse:

Path dir = Path.of("output/reports/2024");

// Creates all missing intermediate directories:
Files.createDirectories(dir);

// Creates a single directory (fails if parent missing):
Files.createDirectory(Path.of("output/reports/2025"));

Temporäre Dateien und Verzeichnisse

Erstellen Sie temporäre Dateien sicher — die JVM kann sie bereinigen:

// Temp file in default temp directory
Path tmp = Files.createTempFile("prefix_", ".txt");
Files.writeString(tmp, "temp data");
System.out.println(tmp); // something like /tmp/prefix_12345.txt

// Temp directory
Path tmpDir = Files.createTempDirectory("work_");
System.out.println(tmpDir);

Zeilen mit Files.lines streamen

Files.lines() gibt einen verzögerten Stream<String> zurück — für große Dateien ist das besser als readAllLines, da nicht der gesamte Inhalt in den Speicher geladen wird:

try (var stream = Files.lines(Path.of("large.log"))) {
    long errorCount = stream
        .filter(l -> l.contains("ERROR"))
        .count();
    System.out.println("Errors: " + errorCount);
} // stream (and underlying reader) closed automatically

Ressourcen aus dem Classpath lesen

Kombinieren Sie getClass().getResourceAsStream() mit NIO-Kopiervorgängen, um Ressourcen zu laden:

try (var in = getClass().getResourceAsStream("/config.json")) {
    Path tmp = Files.createTempFile("config", ".json");
    Files.copy(in, tmp, StandardCopyOption.REPLACE_EXISTING);
    String json = Files.readString(tmp);
    System.out.println(json);
}

Kurzer Check

Welche Methode sollten Sie verwenden, um eine große Logdatei zu lesen, ohne alle Zeilen gleichzeitig in den Speicher zu laden?

Zusammenfassung: Files-Hilfsmethoden

Die wichtigsten Punkte:

  • Files.readString/readAllLines/readAllBytes — gesamte Datei lesen
  • Files.writeString/write — Zeichenkette oder Zeilen schreiben
  • Files.copy/move mit StandardCopyOption — kopieren/umbenennen/verschieben
  • Files.delete/deleteIfExists — sicheres Löschen
  • Files.lines — verzögerter Stream für große Dateien (verwenden Sie try-with-resources)

Häufig gestellte Fragen

Ist die Lektion „Files-Utility: Lesen, Schreiben, Kopieren, Verschieben“ kostenlos?

Ja — der vollständige Text von „Files-Utility: Lesen, Schreiben, Kopieren, Verschieben“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Files-Utility: Lesen, Schreiben, Kopieren, Verschieben“?

Verwenden Sie Files.readString, writeString, copy, move und delete für gängige Dateioperationen. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Files-Utility: Lesen, Schreiben, Kopieren, Verschieben“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Path: Dateipfade darstellen
  2. Files-Utility: Lesen, Schreiben, Kopieren, Verschieben
  3. Verzeichnisbäume mit Files.walk durchlaufen
  4. WatchService: Dateiänderungen überwachen
← Zurück zu Java Academy