用Java列出文件的最佳方法，按修改日期排序？

我想得到一个目录中的文件列表，但我想对它进行排序，以使最旧的文件排在第一位。我的解决方案是调用File.listFiles，然后根据File.lastModified使用列表，但我想知道是否有更好的方法

编辑：根据建议，我目前的解决方案是使用匿名比较器：

File[] files = directory.listFiles();

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

File[]files=directory.listFiles（）；
Arrays.sort（文件，新的Comparator（）{
公共整数比较（文件f1、文件f2）
{
返回Long.valueOf（f1.lastModified（））.compareTo（f2.lastModified（））；
} });

我认为你的解决方案是唯一明智的办法。获取文件列表的唯一方法是使用，文档中指出，这不保证返回文件的顺序。因此，您需要编写一个应用程序，将其与文件数组一起使用并传递到。

您可能还会看到，它有一个内置的和许多其他用于处理文件的实用程序。

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

但是，它更多的是代码，所以只有当您主要关注速度，并且在实践中可以测量到速度时，才应该使用它（我没有检查）

类对实现了可比较的{
公共长t；
公共文件f；
公共对（文件）{
f=文件；
t=file.lastModified（）；
}
公共整数比较对象（对象o）{
长u=（（对）o.t；
返回t

你可以试试番石榴：

函数getLastModified=新函数（）{
公共长应用（文件）{
返回文件.lastModified（）；
}
};
List orderedFiles=Ordering.natural（）.onResultOf（getLastModified）。
分类副本（文件）；

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

---

爪哇8+

private static List listFilesOldestFirst（最终字符串directoryPath）引发IOException{
try（final Stream fileStream=Files.list（path.get（directoryPath）））{
返回文件流
.map（路径：：toFile）
.collect（Collectors.toMap（Function.identity（），File:：lastModified））
.entrySet（）
.stream（）
.sorted（Map.Entry.comparingByValue（））
//.sorted（Collections.reverseOrder（Map.Entry.comparingByValue（））//如果希望先列出最新的文件，请将前一行替换为此行
.map（map.Entry:：getKey）
.map（File:：toPath）//如果希望使用列表而不是列表，请删除此行
.collect（Collectors.toList（））；
}
}

爪哇7

private static List listFilesOldestFirst（最终字符串directoryPath）引发IOException{
最终列表文件=Arrays.asList（新文件（directoryPath.listFiles（））；
最终映射constantLastModifiedTimes=新HashMap（）；
用于（最终文件f:文件）{
constantLastModifiedTimes.put（f，f.lastModified（））；
}
Collections.sort（文件、新比较器（）{
@凌驾
公共整数比较（最终文件f1，最终文件f2）{
返回constantLastModifiedTimes.get（f1）.compareTo（constantLastModifiedTimes.get（f2））；
}
});
归还文件；
}

这两种解决方案都会创建一个临时映射数据结构，以便为目录中的每个文件保存一个恒定的上次修改时间。我们需要这样做的原因是，如果您的文件在执行排序时被更新或修改，那么您的比较器将违反比较器接口的通用合同的传递性要求，因为在比较过程中，最后修改的时间可能会改变

另一方面，如果您知道文件在排序过程中不会被更新或修改，那么您几乎可以不回答这个问题，我倾向于：

Java 8+（排序期间无并发修改）

private static List listFilesOldestFirst（最终字符串directoryPath）引发IOException{
try（final Stream fileStream=Files.list（path.get（directoryPath）））{
返回文件流
.map（路径：：toFile）
.sorted（Comparator.comparing（文件：：lastModified））
.map（File:：toPath）//如果希望使用列表而不是列表，请删除此行
.collect（Collectors.toList（））；
}
}

注意：我知道在上面的示例中，通过在排序流操作中使用api，您可以避免与文件对象之间的转换，但是，您需要处理lambda中已检查的IO异常，这始终是一个难题。我想说，如果性能非常关键，以至于转换是不可接受的，那么我要么将lambda中的checked IOException作为未选中的IOException传播，要么干脆放弃Files api，只处理文件对象：

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

final List sorted=Arrays.asList（新文件（directoryPathString.listFiles（））；
sorted.sort（Comparator.comparing（File:：lastModified））；

类似的方法有什么好处，但没有对长对象进行装箱：

File[] files = directory.listFiles();

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

File[]files=directory.listFiles（）；
Arrays.sort（文件，新的Comparator（）{
公共整数比较（文件f1、文件f2）{
返回Long.compare（f1.lastModified（），f2.lastM
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);

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());
    }
}

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;
}

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());
    }
}

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

File[] files = directory.listFiles();

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

 import org.apache.commons.io.comparator.LastModifiedFileComparator;  


File[] files = directory.listFiles();
        Arrays.sort(files, LastModifiedFileComparator.LASTMODIFIED_COMPARATOR);
        for (File file : files) {
            Date lastMod = new Date(file.lastModified());
            System.out.println("File: " + file.getName() + ", Date: " + lastMod + "");
        }

org.apache.commons.io.comparator.LastModifiedFileComparator

public static void main(String[] args) throws IOException {
        File directory = new File(".");
        // get just files, not directories
        File[] files = directory.listFiles((FileFilter) FileFileFilter.FILE);

        System.out.println("Default order");
        displayFiles(files);

        Arrays.sort(files, LastModifiedFileComparator.LASTMODIFIED_COMPARATOR);
        System.out.println("\nLast Modified Ascending Order (LASTMODIFIED_COMPARATOR)");
        displayFiles(files);

        Arrays.sort(files, LastModifiedFileComparator.LASTMODIFIED_REVERSE);
        System.out.println("\nLast Modified Descending Order (LASTMODIFIED_REVERSE)");
        displayFiles(files);

    }

File downloadDir = new File("mypath");    
File[] list = downloadDir.listFiles();
    for (int i = list.length-1; i >=0 ; i--) {
        //use list.getName to get the name of the file
    }

private static List<File> sortByLastModified(String dirPath) {
    List<File> files = listFilesRec(dirPath);
    Collections.sort(files, new Comparator<File>() {
        public int compare(File o1, File o2) {
            return Long.compare(o1.lastModified(), o2.lastModified());
        }
    });
    return files;
}

File[] files = directory.listFiles();
Arrays.sort(files, Comparator.comparingLong(File::lastModified));

File[] files = directory.listFiles();
Arrays.sort(files, Comparator.comparingLong(File::lastModified).reversed());

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

list.add(1, object1)
list.add(2, object3)
list.add(2, object2)

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());

files = Arrays.stream(files)
        .map(FileWithLastModified::ofFile)
        .sorted(comparingLong(FileWithLastModified::lastModified))
        .map(FileWithLastModified::file)
        .toArray(File[]::new);

private static class FileWithLastModified {
    private final File file;
    private final long lastModified;

    private FileWithLastModified(File file, long lastModified) {
        this.file = file;
        this.lastModified = lastModified;
    }

    public static FileWithLastModified ofFile(File file) {
        return new FileWithLastModified(file, file.lastModified());
    }

    public File file() {
        return file;
    }

    public long lastModified() {
        return lastModified;
    }
}