Java文件遍历案例如何开发

wen java案例 2026-07-01 252

本文目录导读：

Java文件遍历案例如何开发

基础递归遍历
带过滤器的遍历
使用Java NIO (现代方式)
实用工具类
实战示例：文件搜索器
性能优化建议
使用示例

我来详细介绍Java文件遍历的几种开发方式,从基础到高级：

基础递归遍历

简单文件遍历

import java.io.File;
public class FileTraversalBasic {
    public static void traverseDirectory(File dir) {
        if (!dir.exists() || !dir.isDirectory()) {
            System.out.println("目录不存在或不是文件夹");
            return;
        }
        File[] files = dir.listFiles();
        if (files == null) return;
        for (File file : files) {
            if (file.isDirectory()) {
                System.out.println("[目录] " + file.getAbsolutePath());
                traverseDirectory(file); // 递归遍历
            } else {
                System.out.println("[文件] " + file.getAbsolutePath());
            }
        }
    }
    public static void main(String[] args) {
        traverseDirectory(new File("C:/your/path"));
    }
}

带过滤器的遍历

文件类型过滤

import java.io.File;
import java.io.FileFilter;
public class FileTraversalWithFilter {
    // 按文件扩展名过滤
    public static void searchByExtension(File dir, String extension) {
        File[] files = dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.isDirectory()) return true; // 继续遍历子目录
                return pathname.getName().endsWith(extension);
            }
        });
        if (files == null) return;
        for (File file : files) {
            if (file.isDirectory()) {
                searchByExtension(file, extension);
            } else {
                System.out.println("找到文件: " + file.getAbsolutePath());
            }
        }
    }
    public static void main(String[] args) {
        // 查找所有.java文件
        searchByExtension(new File("C:/project"), ".java");
    }
}

使用Java NIO (现代方式)

NIO文件遍历

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
public class FileTraversalNIO {
    // 简单遍历
    public static void simpleWalk(Path start) throws IOException {
        Files.walk(start)
             .forEach(path -> {
                 if (Files.isDirectory(path)) {
                     System.out.println("[目录] " + path);
                 } else {
                     System.out.println("[文件] " + path);
                 }
             });
    }
    // 使用FileVisitor自定义遍历逻辑
    public static void walkWithVisitor(Path start) throws IOException {
        Files.walkFileTree(start, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                System.out.println("进入目录: " + dir);
                return FileVisitResult.CONTINUE;
            }
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                System.out.println("访问文件: " + file);
                System.out.println("  大小: " + attrs.size() + " 字节");
                System.out.println("  最后修改: " + attrs.lastModifiedTime());
                return FileVisitResult.CONTINUE;
            }
            @Override
            public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
                System.err.println("访问失败: " + file);
                return FileVisitResult.CONTINUE;
            }
            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                System.out.println("离开目录: " + dir);
                return FileVisitResult.CONTINUE;
            }
        });
    }
    // 搜索指定文件
    public static void searchFile(Path start, String filename) throws IOException {
        Files.walkFileTree(start, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                if (file.getFileName().toString().equals(filename)) {
                    System.out.println("找到文件: " + file.toAbsolutePath());
                }
                return FileVisitResult.CONTINUE;
            }
        });
    }
}

实用工具类

完整的文件遍历工具

import java.io.File;
import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
import java.util.List;
public class FileTraversalUtils {
    // 获取所有文件（递归）
    public static List<File> getAllFiles(File dir) {
        List<File> resultList = new ArrayList<>();
        collectFiles(dir, resultList);
        return resultList;
    }
    private static void collectFiles(File dir, List<File> list) {
        File[] files = dir.listFiles();
        if (files == null) return;
        for (File file : files) {
            list.add(file);
            if (file.isDirectory()) {
                collectFiles(file, list);
            }
        }
    }
    // 获取指定扩展名的文件
    public static List<File> getFilesByExtension(File dir, String extension) {
        List<File> resultList = new ArrayList<>();
        findFilesByExtension(dir, extension, resultList);
        return resultList;
    }
    private static void findFilesByExtension(File dir, String extension, List<File> list) {
        File[] files = dir.listFiles();
        if (files == null) return;
        for (File file : files) {
            if (file.isDirectory()) {
                findFilesByExtension(file, extension, list);
            } else if (file.getName().endsWith(extension)) {
                list.add(file);
            }
        }
    }
    // 计算目录大小
    public static long getDirectorySize(File dir) {
        long size = 0;
        File[] files = dir.listFiles();
        if (files == null) return 0;
        for (File file : files) {
            if (file.isDirectory()) {
                size += getDirectorySize(file);
            } else {
                size += file.length();
            }
        }
        return size;
    }
    // 获取目录结构（树形展示）
    public static void printDirectoryTree(File dir, String prefix) {
        File[] files = dir.listFiles();
        if (files == null) return;
        for (File file : files) {
            if (file.isDirectory()) {
                System.out.println(prefix + "├── [目录] " + file.getName());
                printDirectoryTree(file, prefix + "│   ");
            } else {
                System.out.println(prefix + "├── [文件] " + file.getName() + 
                                 " (" + formatFileSize(file.length()) + ")");
            }
        }
    }
    private static String formatFileSize(long bytes) {
        if (bytes < 1024) return bytes + "B";
        if (bytes < 1024 * 1024) return String.format("%.1fKB", bytes / 1024.0);
        return String.format("%.1fMB", bytes / (1024.0 * 1024));
    }
}

实战示例：文件搜索器

命令行文件搜索工具

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class FileSearcher {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入要搜索的目录路径: ");
        String dirPath = scanner.nextLine();
        System.out.print("请输入搜索关键词: ");
        String keyword = scanner.nextLine();
        System.out.print("搜索文件类型 (如 .java, 留空搜索所有): ");
        String extension = scanner.nextLine();
        File dir = new File(dirPath);
        if (!dir.exists() || !dir.isDirectory()) {
            System.out.println("无效的目录路径!");
            return;
        }
        System.out.println("\n开始搜索...");
        List<File> results = new ArrayList<>();
        searchFiles(dir, keyword, extension, results);
        System.out.println("\n搜索结果 (" + results.size() + " 个文件):");
        for (File file : results) {
            System.out.println(file.getAbsolutePath());
        }
        scanner.close();
    }
    private static void searchFiles(File dir, String keyword, String extension, List<File> results) {
        File[] files = dir.listFiles();
        if (files == null) return;
        for (File file : files) {
            if (file.isDirectory()) {
                searchFiles(file, keyword, extension, results);
            } else {
                boolean matchKeyword = keyword.isEmpty() || 
                    file.getName().toLowerCase().contains(keyword.toLowerCase());
                boolean matchExtension = extension.isEmpty() || 
                    file.getName().endsWith(extension);
                if (matchKeyword && matchExtension) {
                    results.add(file);
                }
            }
        }
    }
}

性能优化建议

流式处理大目录

import java.io.IOException;
import java.nio.file.*;
import java.util.stream.Stream;
public class EfficientFileTraversal {
    // 使用Stream + try-with-resources自动关闭
    public static void efficientWalk(Path dir) throws IOException {
        try (Stream<Path> stream = Files.walk(dir)) {
            stream.filter(Files::isRegularFile)
                  .filter(path -> path.toString().endsWith(".txt"))
                  .forEach(System.out::println);
        }
    }
    // 限制遍历深度
    public static void limitedDepthWalk(Path dir, int maxDepth) throws IOException {
        try (Stream<Path> stream = Files.walk(dir, maxDepth)) {
            stream.forEach(System.out::println);
        }
    }
}

使用示例

public class Main {
    public static void main(String[] args) throws IOException {
        // 基础递归遍历
        FileTraversalBasic.traverseDirectory(new File("C:/test"));
        // NIO方式
        FileTraversalNIO.walkWithVisitor(Paths.get("C:/test"));
        // 使用工具类
        List<File> allFiles = FileTraversalUtils.getAllFiles(new File("C:/test"));
        System.out.println("总文件数: " + allFiles.size());
        // 高效遍历
        EfficientFileTraversal.efficientWalk(Paths.get("C:/test"));
    }
}

这些示例涵盖了从简单到复杂的文件遍历实现,你可以根据实际需求选择合适的方式，对于大型目录，建议使用NIO方式，性能更好且更容易控制。

本文地址： https://bmjup.com/post/13684.html