0Pricing
Java Academy · Lekcja

Przechodzenie po drzewach katalogów za pomocą Files.walk

Rekurencyjnie wyświetlaj pliki, filtruj je według rozszerzenia i obliczaj rozmiary katalogów za pomocą Files.walk.

Przechodzenie po drzewach katalogów za pomocą Files.walk to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Przegląd Files.walk

Files.walk(startPath) zwraca leniwy Stream<Path>, który rekurencyjnie wylicza wszystkie pliki i katalogi, zaczynając od podanej ścieżki. Przechodzenie odbywa się w głąb i obejmuje również samą ścieżkę początkową.

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

Ograniczanie głębokości

Podaj maksymalną głębokość, aby zapobiec zbyt głębokiej rekurencji:

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);
}

Filtrowanie według typu pliku

Połącz z Files.isRegularFile() lub Files.isDirectory(), aby filtrować:

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

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

Filtrowanie według rozszerzenia

Znajdź wszystkie pliki z określonym rozszerzeniem:

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);
}

Obliczanie rozmiaru katalogu

Sumuj rozmiary wszystkich plików znajdujących się w katalogu:

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 a Files.walk

Files.list(dir) wyświetla tylko bezpośrednią zawartość pojedynczego katalogu (jak ls). Files.walk przechodzi również do podkatalogów.

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

Files.find do wyszukiwania według atrybutów

Files.find(root, depth, matcher) jest wydajniejsze niż połączenie walk+filter, gdy wyszukiwanie odbywa się na podstawie atrybutów pliku:

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));
}

Usuwanie drzewa katalogów

Użyj walk + sorted(reversed), aby usunąć katalog wraz z całą zawartością (najgłębsze pliki najpierw):

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(); }
          });
}

Kopiowanie drzewa katalogów

Przejdź po drzewie źródłowym i skopiuj każdy plik, zachowując strukturę katalogów:

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); }
    });
}

Obsługa niedostępnych plików

Files.walk zgłasza IOException, jeśli napotka katalog, którego nie może odczytać. Używaj ostrożnie FileVisitOption.FOLLOW_LINKS — pętle dowiązań symbolicznych mogą spowodować nieskończoną rekurencję.

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

walkFileTree: przechodzenie oparte na zdarzeniach

Aby uzyskać większą kontrolę (wizyty przed i po przejściu oraz obsługę błędów), użyj Files.walkFileTree() wraz z 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;
    }
});

Szybkie sprawdzenie

Której metody Files należy użyć, aby wyświetlić WYŁĄCZNIE bezpośrednie elementy katalogu (bez rekurencji)?

Podsumowanie: Files.walk

Najważniejsze informacje:

  • Files.walk(root) — rekurencyjny, leniwy strumień wszystkich ścieżek
  • Zawsze używaj try-with-resources, aby zamknąć strumień
  • Filtruj za pomocą Files.isRegularFile/isDirectory; filtruj według rozszerzenia za pomocą endsWith
  • Files.list(dir) — tylko bezpośrednie elementy
  • Files.find — wydajne wyszukiwanie według atrybutów
  • walkFileTree — przechodzenie oparte na zdarzeniach z wywołaniami zwrotnymi przed i po odwiedzeniu

Często zadawane pytania

Czy lekcja „Przechodzenie po drzewach katalogów za pomocą Files.walk” jest bezpłatna?

Tak — pełny tekst „Przechodzenie po drzewach katalogów za pomocą Files.walk” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Przechodzenie po drzewach katalogów za pomocą Files.walk”?

Rekurencyjnie wyświetlaj pliki, filtruj je według rozszerzenia i obliczaj rozmiary katalogów za pomocą Files.walk. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Przechodzenie po drzewach katalogów za pomocą Files.walk”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Path: reprezentowanie lokalizacji plików
  2. Narzędzie Files: odczyt, zapis, kopiowanie i przenoszenie
  3. Przechodzenie po drzewach katalogów za pomocą Files.walk
  4. WatchService: monitorowanie zmian plików
← Powrót do Java Academy