Java 实例 – 遍历目录（保姆级教程）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

前言：为什么需要遍历目录？

在 Java 开发中，我们经常需要与文件系统进行交互，例如读取配置文件、处理日志、批量处理图片等场景。而目录遍历是这些操作的基础能力之一。想象一下，当需要统计某个项目目录下的所有 Java 文件数量时，或者需要批量压缩指定目录下的旧日志文件时，目录遍历就是解决问题的第一步。

本文将通过循序渐进的方式，从基础概念讲到实战案例，帮助读者掌握 Java 中遍历目录的多种方法。我们将对比传统 File 类与 NIO 新 API 的差异，分析不同场景下的最佳实践，并通过具体代码示例展示如何实现递归遍历、过滤特定文件类型等常见需求。

一、目录遍历的核心概念解析

1.1 什么是目录遍历？

目录遍历（Directory Traversal）是指程序按照一定规则访问文件系统中的目录结构，逐个读取目录中的文件和子目录。这类似于在文件资源管理器中展开所有文件夹，逐个查看每个文件的过程。

形象比喻：可以将目录结构想象成一棵大树，根目录是树干，子目录是树枝，文件是树叶。遍历目录就像用剪刀沿着树干向上攀爬，同时剪下所有找到的树叶。

1.2 目录遍历的两种模式

• 广度优先遍历（BFS）：先遍历当前目录的所有文件，再逐层访问子目录。这类似于把所有树枝上的树叶都剪完，再处理下一层分支。
• 深度优先遍历（DFS）：沿着某个子目录一直深入到底，再回溯处理其他分支。这像顺着一根树枝一直走到尽头，再返回处理其他分支。

Java 标准库中默认提供的是深度优先遍历的实现方式，但通过调整代码逻辑，我们也可以实现广度优先遍历。

二、传统方法：使用 File 类实现遍历

2.1 File 类的基础用法

Java 的 java.io.File 类是文件操作的经典工具。通过其方法可以获取目录下的文件列表，并判断文件类型：

File directory = new File("/path/to/directory");
if (directory.isDirectory()) {
    File[] files = directory.listFiles();
    if (files != null) {
        for (File file : files) {
            if (file.isFile()) {
                System.out.println("文件：" + file.getName());
            } else if (file.isDirectory()) {
                System.out.println("目录：" + file.getName());
            }
        }
    }
}

2.2 递归实现深度优先遍历

要完整遍历目录树，需要递归调用遍历子目录：

public static void traverseDirectory(File directory) {
    if (!directory.isDirectory()) {
        System.out.println("非目录路径：" + directory.getAbsolutePath());
        return;
    }

    File[] files = directory.listFiles();
    if (files == null) return;

    for (File file : files) {
        if (file.isFile()) {
            System.out.println("文件：" + file.getAbsolutePath());
        } else {
            System.out.println("进入子目录：" + file.getAbsolutePath());
            traverseDirectory(file); // 递归调用
        }
    }
}

注意事项：

• 需要处理 listFiles() 返回 null 的情况（例如无读取权限）
• 递归深度过深可能导致栈溢出，极端情况下需改用迭代方式

三、NIO 新特性：Files.walk() 简化遍历

Java 8 引入的 java.nio.file.Files 类提供了更简洁的 API，通过 walk() 方法可以轻松实现流式遍历：

import java.nio.file.*;
import java.io.IOException;

public class DirectoryTraversal {
    public static void main(String[] args) {
        Path startPath = Paths.get("/path/to/directory");

        try (Stream<Path> stream = Files.walk(startPath)) {
            stream.forEach(path -> {
                if (Files.isDirectory(path)) {
                    System.out.println("目录：" + path);
                } else {
                    System.out.println("文件：" + path);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.1 Files.walk() 的核心优势

3.2 参数化遍历深度

通过 Files.walk() 的第二个参数可以限制遍历深度：

// 仅遍历当前目录（深度为1）
Files.walk(startPath, 1)

// 遍历最多3层目录
Files.walk(startPath, 3)

四、实战案例：统计目录下的 Java 文件

4.1 需求场景

假设需要统计某个项目目录下所有 .java 文件的数量和总行数。

4.2 实现方案设计

1. 遍历所有文件
2. 过滤出 .java 后缀的文件
3. 逐个读取文件内容统计行数
4. 聚合统计结果

4.3 代码实现

public class JavaFileCounter {
    public static void main(String[] args) {
        Path rootPath = Paths.get("/path/to/project");
        long totalFiles = 0;
        long totalLines = 0;

        try (Stream<Path> stream = Files.walk(rootPath)) {
            totalFiles = stream
                .filter(Files::isRegularFile)
                .filter(path -> path.toString().endsWith(".java"))
                .count();

            totalLines = Files.walk(rootPath)
                .filter(Files::isRegularFile)
                .filter(path -> path.toString().endsWith(".java"))
                .mapToLong(JavaFileCounter::countLinesInFile)
                .sum();
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("Java 文件总数：" + totalFiles);
        System.out.println("总代码行数：" + totalLines);
    }

    private static long countLinesInFile(Path path) {
        try {
            return Files.lines(path).count();
        } catch (IOException e) {
            System.err.println("读取文件失败：" + path);
            return 0;
        }
    }
}

关键点解析：

• 使用 Files.walk() 结合 Stream API 实现高效处理
• filter() 方法实现文件类型过滤
• mapToLong() 将文件路径映射为行数，最终通过 sum() 聚合

五、高级技巧与注意事项

5.1 异常处理的正确姿势

文件操作中需要特别关注以下异常场景：

try {
    // 遍历代码
} catch (IOException e) {
    // 处理 I/O 异常
} catch (SecurityException e) {
    // 处理权限不足问题
}

5.2 性能优化建议

• 避免过度递归：当目录层级过深时，改用栈结构实现迭代遍历
• 缓存文件信息：对于需要多次访问的目录，可缓存文件列表
• 并行处理：使用 Files.walk(FileSystems.getDefault().supportedFileAttributeViews()) 结合并行流

5.3 安全性注意事项

• 路径遍历漏洞防范：在处理用户输入的路径时，务必验证路径是否属于安全目录
• 权限隔离：在服务器环境应避免使用超级用户权限运行文件遍历任务

六、总结与进阶方向

本文通过三个层面讲解了 Java 目录遍历的核心技术：

1. 基础层：File 类的传统递归实现
2. 进阶层：NIO 的 Files.walk() 流式处理
3. 实战层：统计代码行数的完整案例

未来学习方向建议：

• 探索 WatchService 实现目录变化监听
• 学习 Apache Commons IO 工具库中的目录遍历增强功能
• 研究分布式文件系统（如 HDFS）的遍历实现原理

通过掌握本文介绍的方法，开发者可以高效应对文件系统操作中的常见需求。当面对复杂场景时，建议结合日志记录、异常监控和性能分析工具，构建健壮的文件处理系统。