我认为你的解决办法是唯一明智的办法。获取文件列表的唯一方法是使用File.listFiles()，文档声明这不能保证返回的文件的顺序。因此，您需要编写一个使用File.lastModified()的比较器，并将其与文件数组一起传递给Arrays.sort()。

Collections.sort(listFiles, new Comparator<File>() {
        public int compare(File f1, File f2) {
            return Long.compare(f1.lastModified(), f2.lastModified());
        }
    });

其中listFiles是数组列表中所有文件的集合

类似的方法是什么，但没有对Long对象进行装箱:

File[] files = directory.listFiles();

Arrays.sort(files, new Comparator<File>() {
    public int compare(File f1, File f2) {
        return Long.compare(f1.lastModified(), f2.lastModified());
    }
});

如果正在排序的文件可以在执行排序的同时被修改或更新:

Java 8 +

private static List<Path> listFilesOldestFirst(final String directoryPath) throws IOException {
    try (final Stream<Path> fileStream = Files.list(Paths.get(directoryPath))) {
        return fileStream
            .map(Path::toFile)
            .collect(Collectors.toMap(Function.identity(), File::lastModified))
            .entrySet()
            .stream()
            .sorted(Map.Entry.comparingByValue())
//            .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))  // replace the previous line with this line if you would prefer files listed newest first
            .map(Map.Entry::getKey)
            .map(File::toPath)  // remove this line if you would rather work with a List<File> instead of List<Path>
            .collect(Collectors.toList());
    }
}

Java 7

private static List<File> listFilesOldestFirst(final String directoryPath) throws IOException {
    final List<File> files = Arrays.asList(new File(directoryPath).listFiles());
    final Map<File, Long> constantLastModifiedTimes = new HashMap<File,Long>();
    for (final File f : files) {
        constantLastModifiedTimes.put(f, f.lastModified());
    }
    Collections.sort(files, new Comparator<File>() {
        @Override
        public int compare(final File f1, final File f2) {
            return constantLastModifiedTimes.get(f1).compareTo(constantLastModifiedTimes.get(f2));
        }
    });
    return files;
}

这两种解决方案都创建一个临时映射数据结构，为目录中的每个文件保存一个固定的最后修改时间。我们需要这样做的原因是，如果你的文件在你的排序执行时被更新或修改，那么你的比较器将违反比较器接口一般契约的传递性要求，因为最后修改的时间可能在比较期间发生变化。

另一方面，如果你知道文件在排序过程中不会被更新或修改，你就可以得到这个问题的任何其他答案，其中我倾向于:

Java 8+(在排序期间没有并发修改)

private static List<Path> listFilesOldestFirst(final String directoryPath) throws IOException {
    try (final Stream<Path> fileStream = Files.list(Paths.get(directoryPath))) {
        return fileStream
            .map(Path::toFile)
            .sorted(Comparator.comparing(File::lastModified))
            .map(File::toPath)  // remove this line if you would rather work with a List<File> instead of List<Path>
            .collect(Collectors.toList());
    }
}

Note: I know you can avoid the translation to and from File objects in the above example by using Files::getLastModifiedTime api in the sorted stream operation, however, then you need to deal with checked IO exceptions inside your lambda which is always a pain. I'd say if performance is critical enough that the translation is unacceptable then I'd either deal with the checked IOException in the lambda by propagating it as an UncheckedIOException or I'd forego the Files api altogether and deal only with File objects:

final List<File> sorted = Arrays.asList(new File(directoryPathString).listFiles());
sorted.sort(Comparator.comparing(File::lastModified));

有一种非常简单方便的方法来处理这个问题，不需要任何额外的比较器。只需将修改后的日期编码到具有文件名的字符串中，对其排序，然后再次将其剥离。

使用固定长度为20的字符串，将修改后的日期(长)放入其中，并以前导零填充。然后将文件名附加到这个字符串:

String modified_20_digits = ("00000000000000000000".concat(Long.toString(temp.lastModified()))).substring(Long.toString(temp.lastModified()).length()); 

result_filenames.add(modified_20_digits+temp.getAbsoluteFile().toString());

事情是这样的:

Filename1: C:\data\file1.html最近修改:1532914451455最近修改20数字:00000001532914451455

Filename1: C:\data\file2.html最近修改:1532918086822最近修改20数字:00000001532918086822

将文件名转换为:

Filename1: 00000001532914451455 c: \ \ file1.html数据

Filename2: 00000001532918086822 c: \ \ file2.html数据

然后你可以对这个列表进行排序。

你所需要做的就是稍后再次剥离这20个字符(在Java 8中，你可以使用.replaceAll函数用一行来剥离整个数组)

让数组名称->文件。

Ascending -> Arrays.sort(files, (o1, o2) -> Long.compare(o1.lastModified(), o2.lastModified()));

Descending -> Arrays.sort(files, (o1, o2) -> Long.compare(o2.lastModified(), o1.lastModified()));