0Pricing
Java Academy · Lección

Recorrido de árboles de directorios con Files.walk

Enumere archivos de forma recursiva, filtre por extensión y calcule tamaños de directorios con Files.walk.

Recorrido de árboles de directorios con Files.walk es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Descripción general de Files.walk

Files.walk(startPath) devuelve un Stream<Path> diferido que enumera recursivamente todos los archivos y directorios a partir de la ruta indicada. Realiza un recorrido en profundidad e incluye la propia ruta inicial.

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

Limitar la profundidad

Proporcione una profundidad máxima para evitar una recursión demasiado profunda:

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

Filtrar por tipo de archivo

Combínelo con Files.isRegularFile() o Files.isDirectory() para filtrar:

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

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

Filtrar por extensión

Busque todos los archivos con una extensión específica:

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

Calcular el tamaño de un directorio

Sume los tamaños de todos los archivos que se encuentran bajo un directorio:

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

Files.list(dir) enumera solo el contenido inmediato de un único directorio (como ls). Files.walk recorre también los subdirectorios.

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

Files.find para búsquedas basadas en atributos

Files.find(root, depth, matcher) es más eficiente que combinar walk y filter cuando se buscan coincidencias en atributos de archivos:

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

Eliminar un árbol de directorios

Use walk + sorted(reversed) para eliminar un directorio y todo su contenido (primero los archivos más profundos):

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

Copiar un árbol de directorios

Recorra el árbol de origen y copie cada archivo manteniendo la estructura de directorios:

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

Gestionar archivos inaccesibles

Files.walk produce una IOException si encuentra un directorio que no puede leer. Use FileVisitOption.FOLLOW_LINKS con cuidado: los bucles de enlaces simbólicos pueden causar una recursión 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: recorrido basado en eventos

Para un control más preciso (visita previa, visita posterior y gestión de errores), use 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;
    }
});

Comprobación rápida

¿Qué método de Files debe usar para enumerar SOLO los elementos secundarios inmediatos de un directorio (sin recursión)?

Resumen: Files.walk

Aspectos clave:

  • Files.walk(root) — Stream diferido y recursivo de todas las rutas
  • Use siempre try-with-resources para cerrar el flujo
  • Filtre con Files.isRegularFile/isDirectory; filtre por extensión con endsWith
  • Files.list(dir) — solo los elementos secundarios inmediatos
  • Files.find — búsqueda eficiente basada en atributos
  • walkFileTree — basado en eventos, con callbacks de visita previa y posterior

Preguntas frecuentes

¿La lección «Recorrido de árboles de directorios con Files.walk» es gratis?

Sí — el texto completo de «Recorrido de árboles de directorios con Files.walk» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Recorrido de árboles de directorios con Files.walk»?

Enumere archivos de forma recursiva, filtre por extensión y calcule tamaños de directorios con Files.walk. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Recorrido de árboles de directorios con Files.walk»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Path: representación de ubicaciones de archivos
  2. Utilidad Files: leer, escribir, copiar y mover
  3. Recorrido de árboles de directorios con Files.walk
  4. WatchService: supervisión de cambios en archivos
← Volver a Java Academy