Java Academy · Lezione

Attraversare gli alberi di directory con Files.walk

Elenchi ricorsivamente i file, li filtri per estensione e calcoli le dimensioni delle directory con Files.walk.

Lezione 3 di 413 passaggi

Attraversare gli alberi di directory con Files.walk è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Panoramica di Files.walk

Files.walk(startPath) restituisce uno Stream<Path> lazy che elenca ricorsivamente tutti i file e le directory a partire dal percorso specificato. Esegue una visita in profondità e include il percorso iniziale.

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

Limitazione della profondità

Specifichi una profondità massima per evitare ricorsioni troppo profonde:

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

Filtro per tipo di file

Combini Files.isRegularFile() o Files.isDirectory() per filtrare:

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

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

Filtro per estensione

Trovi tutti i file con una specifica estensione:

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

Calcolo delle dimensioni di una directory

Sommi le dimensioni di tutti i file contenuti in una directory:

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

Files.list(dir) elenca solo i contenuti immediati di una singola directory (come ls). Files.walk scende ricorsivamente nelle sottodirectory.

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

Files.find per la ricerca basata sugli attributi

Files.find(root, depth, matcher) è più efficiente di walk+filter quando la ricerca si basa sugli attributi dei file:

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

Eliminazione di un albero di directory

Utilizzi walk + sorted(reversed) per eliminare una directory e tutti i suoi contenuti, elaborando prima i file più profondi:

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

Copia di un albero di directory

Visiti l'albero sorgente e copi ogni file mantenendo la struttura delle directory:

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

Gestione dei file inaccessibili

Files.walk genera IOException se incontra una directory che non può leggere. Utilizzi con cautela FileVisitOption.FOLLOW_LINKS: i cicli tra link simbolici possono causare una ricorsione infinita.

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

walkFileTree: visita basata sugli eventi

Per un controllo più preciso (visita preliminare, visita successiva e gestione degli errori), utilizzi Files.walkFileTree() con un 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;
    }
});

Verifica rapida

Quale metodo di Files dovrebbe utilizzare per elencare SOLO i figli immediati di una directory (senza ricorsione)?

Rispondi nella lezione interattiva

Riepilogo: Files.walk

Punti chiave:

Files.walk(root) — Stream lazy ricorsivo di tutti i percorsi
Utilizzi sempre try-with-resources per chiudere lo stream
Filtri con Files.isRegularFile/isDirectory; filtri per estensione con endsWith
Files.list(dir) — solo i figli immediati
Files.find — ricerca efficiente basata sugli attributi
walkFileTree — visita basata sugli eventi con callback pre/post-visita

Gratis per iniziare

Impara Java con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 104
Lezioni: 374

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Attraversare gli alberi di directory con Files.walk» è gratuita?

Sì — il testo completo di «Attraversare gli alberi di directory con Files.walk» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Attraversare gli alberi di directory con Files.walk»?

Elenchi ricorsivamente i file, li filtri per estensione e calcoli le dimensioni delle directory con Files.walk. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Attraversare gli alberi di directory con Files.walk»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Path: rappresentare i percorsi dei file
Utility Files: leggere, scrivere, copiare e spostare
Attraversare gli alberi di directory con Files.walk
WatchService: monitorare le modifiche ai file

← Torna a Java Academy