Java实现文件大小过滤功能

下面我将提供一个完整的Java实现，用于过滤指定目录中符合大小条件的文件。这个实现包含多种过滤方式，并提供了详细的代码注释。

1. 基础实现：文件大小过滤器

import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;
import java.util.List;

/**
 * 文件大小过滤器实现
 */
public class FileSizeFilter {

    /**
     * 根据文件大小范围过滤文件
     * @param directory 要扫描的目录
     * @param minSize 最小文件大小(字节)
     * @param maxSize 最大文件大小(字节)
     * @return 符合条件的文件列表
     */
    public static List<File> filterFilesBySize(File directory, long minSize, long maxSize) {
        List<File> result = new ArrayList<>();

        if (directory == null || !directory.isDirectory()) {
            throw new IllegalArgumentException("提供的路径不是有效目录");
        }

        File[] files = directory.listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                if (file.isFile()) {
                    long fileSize = file.length();
                    return fileSize >= minSize && fileSize <= maxSize;
                }
                return false;
            }
        });

        if (files != null) {
            for (File file : files) {
                result.add(file);
            }
        }

        return result;
    }

    public static void main(String[] args) {
        // 示例用法
        File directory = new File("C:/TestFiles");
        long minSize = 1024; // 1KB
        long maxSize = 1024 * 1024; // 1MB

        List<File> filteredFiles = filterFilesBySize(directory, minSize, maxSize);

        System.out.println("符合条件的文件(" + minSize + "字节到" + maxSize + "字节):");
        for (File file : filteredFiles) {
            System.out.println(file.getName() + " - " + file.length() + "字节");
        }
    }
}

2. 增强版：支持多种过滤条件和递归扫描

import java.io.File;
import java.util.ArrayList;
import java.util.List;

/**
 * 增强版文件大小过滤器
 */
public class EnhancedFileSizeFilter {

    public enum SizeUnit {
        BYTES(1),
        KB(1024),
        MB(1024 * 1024),
        GB(1024 * 1024 * 1024);

        private final long bytes;

        SizeUnit(long bytes) {
            this.bytes = bytes;
        }

        public long toBytes(long value) {
            return value * bytes;
        }
    }

    /**
     * 根据文件大小范围过滤文件(支持递归)
     * @param directory 要扫描的目录
     * @param minSize 最小文件大小
     * @param maxSize 最大文件大小
     * @param recursive 是否递归子目录
     * @return 符合条件的文件列表
     */
    public static List<File> filterFiles(File directory, long minSize, long maxSize, boolean recursive) {
        List<File> result = new ArrayList<>();

        if (directory == null || !directory.isDirectory()) {
            throw new IllegalArgumentException("提供的路径不是有效目录");
        }

        scanDirectory(directory, minSize, maxSize, recursive, result);

        return result;
    }

    private static void scanDirectory(File directory, long minSize, long maxSize, 
                                     boolean recursive, List<File> result) {
        File[] files = directory.listFiles();
        if (files == null) return;

        for (File file : files) {
            if (file.isFile()) {
                long fileSize = file.length();
                if (fileSize >= minSize && fileSize <= maxSize) {
                    result.add(file);
                }
            } else if (recursive && file.isDirectory()) {
                scanDirectory(file, minSize, maxSize, recursive, result);
            }
        }
    }

    /**
     * 过滤大于指定大小的文件
     */
    public static List<File> filterFilesLargerThan(File directory, long size, boolean recursive) {
        return filterFiles(directory, size, Long.MAX_VALUE, recursive);
    }

    /**
     * 过滤小于指定大小的文件
     */
    public static List<File> filterFilesSmallerThan(File directory, long size, boolean recursive) {
        return filterFiles(directory, 0, size, recursive);
    }

    public static void main(String[] args) {
        // 示例用法
        File directory = new File("C:/TestFiles");
        long minSize = SizeUnit.KB.toBytes(100); // 100KB
        long maxSize = SizeUnit.MB.toBytes(5);   // 5MB

        // 查找100KB到5MB之间的文件(包括子目录)
        List<File> filteredFiles = filterFiles(directory, minSize, maxSize, true);

        System.out.println("符合条件的文件(" + minSize + "字节到" + maxSize + "字节):");
        for (File file : filteredFiles) {
            System.out.println(file.getAbsolutePath() + " - " + file.length() + "字节");
        }

        // 查找大于1GB的文件
        List<File> largeFiles = filterFilesLargerThan(directory, SizeUnit.GB.toBytes(1), true);
        System.out.println("\n大于1GB的文件:");
        largeFiles.forEach(f -> System.out.println(f.getAbsolutePath()));
    }
}

3. 使用Java 8 Stream API的实现

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 使用Java 8 Stream API实现的文件大小过滤器
 */
public class FileSizeFilterJava8 {

    /**
     * 使用Stream API过滤文件
     * @param directoryPath 目录路径
     * @param minSize 最小大小(字节)
     * @param maxSize 最大大小(字节)
     * @param recursive 是否递归
     * @return 符合条件的文件列表
     * @throws IOException
     */
    public static List<File> filterFilesWithStream(String directoryPath, 
                                                 long minSize, 
                                                 long maxSize, 
                                                 boolean recursive) throws IOException {

        int maxDepth = recursive ? Integer.MAX_VALUE : 1;

        try (Stream<Path> pathStream = Files.walk(Paths.get(directoryPath), maxDepth)) {
            return pathStream
                    .filter(Files::isRegularFile)
                    .filter(path -> {
                        try {
                            long size = Files.size(path);
                            return size >= minSize && size <= maxSize;
                        } catch (IOException e) {
                            return false;
                        }
                    })
                    .map(Path::toFile)
                    .collect(Collectors.toList());
        }
    }

    public static void main(String[] args) {
        try {
            String directoryPath = "C:/TestFiles";
            long minSize = 1024 * 1024; // 1MB
            long maxSize = 10 * 1024 * 1024; // 10MB

            List<File> result = filterFilesWithStream(directoryPath, minSize, maxSize, true);

            System.out.println("找到 " + result.size() + " 个符合条件的文件:");
            result.forEach(file -> 
                System.out.printf("%s - %.2f MB%n", 
                    file.getAbsolutePath(), 
                    (double)file.length() / (1024 * 1024))
            );

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. 实用工具类：支持多种过滤条件

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

/**
 * 多功能文件过滤器工具类
 */
public class FileFilterUtility {

    /**
     * 文件过滤条件接口
     */
    public interface FileCondition extends Predicate<File> {}

    /**
     * 按条件过滤文件
     * @param directory 目录
     * @param condition 过滤条件
     * @param recursive 是否递归
     * @return 符合条件的文件列表
     */
    public static List<File> filterFiles(File directory, FileCondition condition, boolean recursive) {
        List<File> result = new ArrayList<>();
        scanFiles(directory, condition, recursive, result);
        return result;
    }

    private static void scanFiles(File file, FileCondition condition, boolean recursive, List<File> result) {
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            if (files != null) {
                for (File f : files) {
                    if (f.isFile() && condition.test(f)) {
                        result.add(f);
                    } else if (recursive && f.isDirectory()) {
                        scanFiles(f, condition, recursive, result);
                    }
                }
            }
        } else if (file.isFile() && condition.test(file)) {
            result.add(file);
        }
    }

    // 预定义的条件工厂方法

    public static FileCondition sizeBetween(long minBytes, long maxBytes) {
        return file -> {
            long size = file.length();
            return size >= minBytes && size <= maxBytes;
        };
    }

    public static FileCondition largerThan(long minBytes) {
        return file -> file.length() >= minBytes;
    }

    public static FileCondition smallerThan(long maxBytes) {
        return file -> file.length() <= maxBytes;
    }

    public static FileCondition exactSize(long exactBytes) {
        return file -> file.length() == exactBytes;
    }

    public static FileCondition and(FileCondition... conditions) {
        return file -> {
            for (FileCondition condition : conditions) {
                if (!condition.test(file)) {
                    return false;
                }
            }
            return true;
        };
    }

    public static FileCondition or(FileCondition... conditions) {
        return file -> {
            for (FileCondition condition : conditions) {
                if (condition.test(file)) {
                    return true;
                }
            }
            return false;
        };
    }

    public static void main(String[] args) {
        File directory = new File("C:/TestFiles");

        // 查找1MB到10MB之间的图片文件
        FileCondition condition = and(
            sizeBetween(1024 * 1024, 10 * 1024 * 1024),
            file -> file.getName().toLowerCase().matches(".*\\.(jpg|png|gif)$")
        );

        List<File> result = filterFiles(directory, condition, true);

        System.out.println("符合条件的文件:");
        result.forEach(file -> 
            System.out.printf("%s - %.2f MB%n", 
                file.getAbsolutePath(), 
                (double)file.length() / (1024 * 1024))
        );
    }
}