类似的方法是什么，但没有对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());
    }
});

如果您有很多文件，这可能会更快。这使用装饰-排序-不装饰模式，以便每个文件的最后修改日期只获取一次，而不是每次排序算法比较两个文件时都获取。这可能会将I/O调用的数量从O(n log n)减少到O(n)。

不过，它的代码更多，所以只有当您主要关注速度时才应该使用这种方法，而且在实践中它确实更快(我没有检查过)。

class Pair implements Comparable {
    public long t;
    public File f;

    public Pair(File file) {
        f = file;
        t = file.lastModified();
    }

    public int compareTo(Object o) {
        long u = ((Pair) o).t;
        return t < u ? -1 : t == u ? 0 : 1;
    }
};

// Obtain the array of (file, timestamp) pairs.
File[] files = directory.listFiles();
Pair[] pairs = new Pair[files.length];
for (int i = 0; i < files.length; i++)
    pairs[i] = new Pair(files[i]);

// Sort them by timestamp.
Arrays.sort(pairs);

// Take the sorted pairs and extract only the file part, discarding the timestamp.
for (int i = 0; i < files.length; i++)
    files[i] = pairs[i].f;

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

使用固定长度为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函数用一行来剥离整个数组)

在java 6中，最好的方法是:

  File[] listaArchivos = folder.listFiles();
            Arrays.sort(listaArchivos, new Comparator<File>() {
                @Override
                public int compare(File f1, File f2) {
                    return (f1.lastModified() < f2.lastModified()) ? -1 : ((f1.lastModified() == f2.lastModified()) ? 0 : 1);
                }
            }); 

你可以试试番石榴。

Function<File, Long> getLastModified = new Function<File, Long>() {
    public Long apply(File file) {
        return file.lastModified();
    }
};

List<File> orderedFiles = Ordering.natural().onResultOf(getLastModified).
                          sortedCopy(files);

使用Java 8+ 这里文件按修改日期降序排序(更新的文件第一次打印)

public void deleteOldFiles(String directory) {
    try {
        File file = new File(directory);
        Arrays.stream(file.listFiles()).filter(File::isFile)
                .sorted((file1, file2) -> {
                    if(file1.lastModified()>file2.lastModified()){
                        return -1;
                    }else if(file1.lastModified()<file2.lastModified()){
                        return 1;
                    }else {
                        return 0;
                    }
                }).forEach(System.out::println);

    } catch (Exception e) {
        System.out.println("No such directory exists: " + directory);
    }
}