0Pricing
Java Academy · Leçon

Parcourir les arborescences de répertoires avec Files.walk

Répertoriez récursivement les fichiers, filtrez-les par extension et calculez la taille des répertoires avec Files.walk.

Parcourir les arborescences de répertoires avec Files.walk est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Présentation de Files.walk

Files.walk(startPath) renvoie un Stream<Path> paresseux qui répertorie récursivement tous les fichiers et répertoires à partir du chemin indiqué. Le parcours est en profondeur et inclut le chemin de départ.

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

Limiter la profondeur

Indiquez une profondeur maximale pour éviter une récursion trop 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);
}

Filtrer par type de fichier

Combinez avec Files.isRegularFile() ou Files.isDirectory() pour filtrer :

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

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

Filtrer par extension

Recherchez tous les fichiers possédant une extension donnée :

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

Calculer la taille d'un répertoire

Additionnez la taille de tous les fichiers situés sous un répertoire :

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

Files.list(dir) répertorie uniquement le contenu immédiat d'un seul répertoire (comme ls). Files.walk parcourt également les sous-répertoires.

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

Files.find pour une recherche basée sur les attributs

Files.find(root, depth, matcher) est plus efficace que walk+filter lorsque la recherche porte sur les attributs des fichiers :

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

Supprimer une arborescence de répertoires

Utilisez walk + sorted(reversed) pour supprimer un répertoire et tout son contenu (en commençant par les fichiers les plus profonds) :

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

Copier une arborescence de répertoires

Parcourez l'arborescence source et copiez chaque fichier en conservant la structure des répertoires :

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

Gérer les fichiers inaccessibles

Files.walk lève une IOException s'il rencontre un répertoire qu'il ne peut pas lire. Utilisez FileVisitOption.FOLLOW_LINKS avec précaution : les boucles de liens symboliques peuvent provoquer une récursion infinie.

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

walkFileTree : parcours basé sur les événements

Pour un contrôle plus précis (visite préalable, visite finale et gestion des erreurs), utilisez Files.walkFileTree() avec 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;
    }
});

Vérification rapide

Quelle méthode Files devez-vous utiliser pour répertorier UNIQUEMENT les enfants immédiats d'un répertoire (sans récursion) ?

Récapitulatif : Files.walk

Points essentiels :

  • Files.walk(root) — flux Stream paresseux et récursif de tous les chemins
  • Utilisez toujours try-with-resources pour fermer le flux
  • Filtrez avec Files.isRegularFile/isDirectory ; filtrez par extension avec endsWith
  • Files.list(dir) — enfants immédiats uniquement
  • Files.find — recherche efficace basée sur les attributs
  • walkFileTree — parcours basé sur les événements avec des rappels de visite préalable et finale

Questions Fréquemment Posées

La leçon « Parcourir les arborescences de répertoires avec Files.walk » est-elle gratuite ?

Oui — le texte complet de « Parcourir les arborescences de répertoires avec Files.walk » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Parcourir les arborescences de répertoires avec Files.walk » ?

Répertoriez récursivement les fichiers, filtrez-les par extension et calculez la taille des répertoires avec Files.walk. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Parcourir les arborescences de répertoires avec Files.walk » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Path : représenter des emplacements de fichiers
  2. Utilitaire Files : lire, écrire, copier, déplacer
  3. Parcourir les arborescences de répertoires avec Files.walk
  4. WatchService : surveiller les changements de fichiers
← Retour à Java Academy