0Pricing
Java Academy · Aula

Percurso de Árvores de Diretórios com Files.walk

Liste arquivos recursivamente, filtre por extensão e calcule os tamanhos dos diretórios com Files.walk.

Percurso de Árvores de Diretórios com Files.walk é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Visão Geral de Files.walk

Files.walk(startPath) retorna um Stream<Path> tardio que lista recursivamente todos os arquivos e diretórios a partir do caminho fornecido. A travessia é em profundidade e inclui o próprio caminho 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

Limitando a Profundidade

Forneça uma profundidade máxima para evitar uma recursão 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);
}

Filtrando por Tipo de Arquivo

Combine com Files.isRegularFile() ou 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);
}

Filtrando por Extensão

Encontre todos os arquivos com uma extensão 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);
}

Calculando o Tamanho de um Diretório

Some

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 em comparação com Files.walk

Files.list(dir) lista apenas o conteúdo imediato de um único diretório (como ls). Files.walk percorre recursivamente os subdiretórios.

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

Files.find para pesquisa baseada em atributos

Files.find(root, depth, matcher) é mais eficiente do que a combinação de walk com filtragem ao pesquisar com base em atributos de arquivos:

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

Exclusão de uma árvore de diretórios

Use walk + sorted(reversed) para excluir um diretório e todo o seu conteúdo (começando pelos arquivos mais 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(); }
          });
}

Cópia de uma árvore de diretórios

Percorra a árvore de origem e use copy para copiar cada arquivo, mantendo a estrutura de diretórios:

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

Como lidar com arquivos inacessíveis

Files.walk lança IOException quando encontra um diretório que não consegue ler. Use FileVisitOption.FOLLOW_LINKS com cuidado — os ciclos de links simbólicos podem causar recursão 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: percurso baseado em eventos

Para ter um controle mais preciso (pré-visita, pós-visita e tratamento de erros), use Files.walkFileTree() com um 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ção rápida

Qual método de Files deve usar para listar ONLY os filhos imediatos de um diretório (sem recursão)?

Recapitulação: Files.walk

Principais conclusões:

  • Files.walk(root) — fluxo recursivo, avaliado sob demanda, de todos os caminhos
  • Use sempre o gerenciamento automático de recursos para fechar o fluxo
  • Filtre por Files.isRegularFile/isDirectory; filtre pela extensão com endsWith
  • Files.list(dir) — apenas os filhos imediatos
  • Files.find — pesquisa eficiente baseada em atributos
  • walkFileTree — baseado em eventos, com funções de retorno de chamada de pré e pós-visita

Perguntas Frequentes

A aula “Percurso de Árvores de Diretórios com Files.walk” é grátis?

Sim — o texto completo de “Percurso de Árvores de Diretórios com Files.walk” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Percurso de Árvores de Diretórios com Files.walk”?

Liste arquivos recursivamente, filtre por extensão e calcule os tamanhos dos diretórios com Files.walk. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Percurso de Árvores de Diretórios com Files.walk”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Path: Representação de Locais de Arquivos
  2. Utilitário Files: Ler, Escrever, Copiar e Mover
  3. Percurso de Árvores de Diretórios com Files.walk
  4. WatchService: Monitoramento de Alterações em Arquivos
← Voltar para Java Academy