如何在Java中高效获取指定文件夹内最新创建的50个文件？

针对你需要从\usr\documents\archive文件夹（含1000个文件）中快速获取最新创建的50个文件的需求，推荐使用**最小堆（PriorityQueue）**的方式实现，相比全量排序更高效，尤其是文件数量持续增长时优势明显。

核心逻辑 #

不需要对所有文件进行全量排序，而是用容量为50的最小堆维护当前找到的最新文件：

• 遍历文件夹中的每个文件，获取其创建时间
• 将文件加入堆中，如果堆的大小超过50，就移除堆中创建时间最早的文件（堆顶元素）
• 遍历结束后，堆中剩下的就是最新的50个文件
• 最后将堆元素反转，即可得到从最新到最旧的顺序

这种方式的时间复杂度为O(n log k)（n是文件总数，k是要获取的文件数），比全量排序的O(n log n)更高效，文件越多优势越显著。

代码实现 #

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;

public class LatestFilesFetcher {
    public static void main(String[] args) {
        // 目标文件夹路径
        Path folderPath = Paths.get("/usr/documents/archive");
        // 要获取的最新文件数量
        int targetCount = 50;

        // 创建最小堆：按文件创建时间升序排序，堆顶是当前堆中最早的文件
        PriorityQueue<Path> minHeap = new PriorityQueue<>(Comparator.comparingLong(path -> {
            try {
                BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
                // 优先取创建时间，若系统不支持则 fallback 到最后修改时间
                return attrs.creationTime().toMillis();
            } catch (IOException e) {
                // 异常处理：返回极小值，确保异常文件被优先排除
                return Long.MIN_VALUE;
            }
        }));

        try {
            // 遍历文件夹中的所有文件（不含子文件夹，若需要递归可改用Files.walk）
            Files.list(folderPath).forEach(path -> {
                if (Files.isRegularFile(path)) { // 只处理普通文件，排除文件夹
                    minHeap.offer(path);
                    // 当堆大小超过目标数量时，移除最早的文件
                    if (minHeap.size() > targetCount) {
                        minHeap.poll();
                    }
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        // 将堆中的文件转为列表，此时是升序（最早到最新），反转后得到最新到最早的顺序
        List<Path> latestFiles = new ArrayList<>(minHeap);
        latestFiles.sort(Comparator.comparingLong(path -> {
            try {
                BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
                return attrs.creationTime().toMillis();
            } catch (IOException e) {
                return Long.MIN_VALUE;
            }
        }).reversed());

        // 输出结果
        System.out.println("最新的50个文件（按创建时间从新到旧）：");
        latestFiles.forEach(path -> System.out.println(path.getFileName()));
    }
}

关键细节说明 #

1. 文件时间的兼容性：部分系统（如Linux）可能不支持文件创建时间的获取，代码中做了 fallback 处理，改用最后修改时间替代（如果需要可以调整逻辑）。
2. 堆的排序规则：最小堆按创建时间升序排列，确保堆顶是当前堆中最早的文件，超过容量时优先移除它。
3. 遍历方式：使用Files.list遍历文件夹，默认只处理当前目录的文件；如果需要递归遍历子文件夹，可替换为Files.walk并指定深度。
4. 异常处理：读取文件属性时可能抛出IO异常，代码中通过返回极小值确保异常文件被优先排除，避免影响整体逻辑。

备选方案（文件数量较少时） #

如果文件总数不多（比如你的场景只有1000个），也可以直接将所有文件存入列表后排序，代码更简洁：

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class SimpleLatestFilesFetcher {
    public static void main(String[] args) {
        Path folderPath = Paths.get("/usr/documents/archive");
        int targetCount = 50;

        try {
            List<Path> latestFiles = Files.list(folderPath)
                    .filter(Files::isRegularFile)
                    .sorted((p1, p2) -> {
                        try {
                            long time1 = Files.readAttributes(p1, BasicFileAttributes.class).creationTime().toMillis();
                            long time2 = Files.readAttributes(p2, BasicFileAttributes.class).creationTime().toMillis();
                            return Long.compare(time2, time1); // 降序排序
                        } catch (IOException e) {
                            return 0;
                        }
                    })
                    .limit(targetCount)
                    .collect(Collectors.toList());

            latestFiles.forEach(path -> System.out.println(path.getFileName()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这种方式代码更直观，但当文件数量达到数万级时，性能会不如堆的实现。

内容的提问来源于stack exchange，提问作者Naren