0Pricing
Java Academy · Lektion

Verzeichnisbäume mit Files.walk durchlaufen

Listen Sie Dateien rekursiv auf, filtern Sie nach Erweiterung und berechnen Sie Verzeichnisgrößen mit Files.walk.

Verzeichnisbäume mit Files.walk durchlaufen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Überblick über Files.walk

Files.walk(startPath) gibt einen verzögerten Stream<Path> zurück, der rekursiv alle Dateien und Verzeichnisse ab dem angegebenen Pfad auflistet. Die Durchsuchung erfolgt in Tiefensuche und schließt den Startpfad selbst ein.

import java.nio.file.*;
import java.util.stream.*;

try (Stream<Path> stream = Files.walk(Path.of("/home/user/projects"))) {
    stream.forEach(System.out::println);
} // stream and underlying resources closed automatically

Tiefe begrenzen

Geben Sie eine maximale Tiefe an, um eine zu tiefe Rekursion zu verhindern:

Path root = Path.of("/home/user/projects");

// Only immediate children (depth 1)
try (var stream = Files.walk(root, 1)) {
    stream.filter(p -> !p.equals(root)) // exclude start path
          .forEach(System.out::println);
}

Nach Dateityp filtern

Kombinieren Sie dies mit Files.isRegularFile() oder Files.isDirectory(), um zu filtern:

Path root = Path.of(".");

try (var stream = Files.walk(root)) {
    long fileCount = stream
        .filter(Files::isRegularFile)
        .count();
    System.out.println("Files: " + fileCount);
}

Nach Erweiterung filtern

Finden Sie alle Dateien mit einer bestimmten Erweiterung:

try (var stream = Files.walk(Path.of("/src"))) {
    List<Path> javaFiles = stream
        .filter(Files::isRegularFile)
        .filter(p -> p.toString().endsWith(".java"))
        .collect(Collectors.toList());
    javaFiles.forEach(System.out::println);
}

Verzeichnisgröße berechnen

Addieren Sie die Größen aller Dateien unterhalb eines Verzeichnisses:

try (var stream = Files.walk(Path.of("/home/user/data"))) {
    long totalBytes = stream
        .filter(Files::isRegularFile)
        .mapToLong(p -> {
            try { return Files.size(p); }
            catch (IOException e) { return 0; }
        })
        .sum();
    System.out.printf("Total: %.2f MB%n", totalBytes / 1_048_576.0);
}

Files.list und Files.walk

Files.list(dir) listet nur den unmittelbaren Inhalt eines einzelnen Verzeichnisses auf (wie ls). Files.walk durchsucht auch Unterverzeichnisse.

// Only immediate children:
try (var stream = Files.list(Path.of("/home/user"))) {
    stream.forEach(System.out::println);
}

Files.find für die attributbasierte Suche

Files.find(root, depth, matcher) ist bei der Suche anhand von Dateiattributen effizienter als walk+filter:

import java.nio.file.attribute.BasicFileAttributes;

try (var stream = Files.find(
        Path.of("/home/user"),
        Integer.MAX_VALUE,
        (p, attrs) -> attrs.isRegularFile() && attrs.size() > 1_000_000
)) {
    stream.forEach(p -> System.out.println("Large file: " + p));
}

Verzeichnisbaum löschen

Verwenden Sie walk + sorted(reversed), um ein Verzeichnis und seinen gesamten Inhalt zu löschen (die Dateien in den tiefsten Verzeichnissen zuerst):

Path toDelete = Path.of("/tmp/workdir");
try (var stream = Files.walk(toDelete)) {
    stream.sorted(Comparator.reverseOrder())
          .forEach(p -> {
              try { Files.delete(p); }
              catch (IOException e) { e.printStackTrace(); }
          });
}

Verzeichnisbaum kopieren

Durchlaufen Sie den Quellbaum und kopieren Sie jede Datei, wobei die Verzeichnisstruktur erhalten bleibt:

Path src = Path.of("/source"), dst = Path.of("/destination");
try (var stream = Files.walk(src)) {
    stream.forEach(p -> {
        try {
            Path target = dst.resolve(src.relativize(p));
            if (Files.isDirectory(p)) Files.createDirectories(target);
            else Files.copy(p, target, StandardCopyOption.REPLACE_EXISTING);
        } catch (IOException e) { throw new RuntimeException(e); }
    });
}

Nicht zugreifbare Dateien behandeln

Files.walk löst eine IOException aus, wenn ein Verzeichnis erreicht wird, das nicht gelesen werden kann. Verwenden Sie FileVisitOption.FOLLOW_LINKS vorsichtig — symbolische Verknüpfungsschleifen können zu einer Endlosrekursion führen.

try (var stream = Files.walk(Path.of("/"),
        FileVisitOption.FOLLOW_LINKS)) { // caution: symlink loops
    // ...
} catch (IOException e) {
    System.err.println("Access error: " + e.getMessage());
}

walkFileTree: Ereignisbasierte Traversierung

Für eine genauere Steuerung (Besuch vor und nach der Verarbeitung sowie Fehlerbehandlung) verwenden Sie Files.walkFileTree() mit einem FileVisitor:

Files.walkFileTree(Path.of("/home/user"), new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
        System.out.println("File: " + file);
        return FileVisitResult.CONTINUE;
    }
    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
        System.out.println("Dir: " + dir);
        return FileVisitResult.CONTINUE;
    }
});

Kurzer Check

Welche Files-Methode sollten Sie verwenden, um NUR die unmittelbaren Unterelemente eines Verzeichnisses aufzulisten (ohne Rekursion)?

Zusammenfassung: Files.walk

Die wichtigsten Punkte:

  • Files.walk(root) — rekursiver verzögerter Stream aller Pfade
  • Verwenden Sie immer try-with-resources, um den Stream zu schließen
  • Filtern Sie mit Files.isRegularFile/isDirectory; filtern Sie nach Erweiterung mit endsWith
  • Files.list(dir) — nur unmittelbare Unterelemente
  • Files.find — effiziente attributbasierte Suche
  • walkFileTree — ereignisbasiert mit Callbacks vor und nach der Verarbeitung

Häufig gestellte Fragen

Ist die Lektion „Verzeichnisbäume mit Files.walk durchlaufen“ kostenlos?

Ja — der vollständige Text von „Verzeichnisbäume mit Files.walk durchlaufen“ 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 „Verzeichnisbäume mit Files.walk durchlaufen“?

Listen Sie Dateien rekursiv auf, filtern Sie nach Erweiterung und berechnen Sie Verzeichnisgrößen mit Files.walk. 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 3 von 4.

Wie lange dauert die Lektion „Verzeichnisbäume mit Files.walk durchlaufen“?

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