Java 获取按上次修改排序的目录中的文件？

在具有新I/OAPI的Java7中，是否有一种简单的方法可以按上次修改的日期列出目录的内容？基本上，我只需要得到最长时间没有修改的文件（按上次修改的升序排序，取第一个文件名）

返回此抽象路径名表示的文件上次修改的时间

您可以使用）并提供

然后比较（）就完成了

如果您确实关心性能，那么只需从文件列表中选择一个具有最大/最小值的文件，这将给您带来O（n）复杂性

在目录的文件对象上使用listFiles（）。将数组转换为arraylist。然后使用Collections类上的静态排序方法和对文件使用getTotalSpace（）方法的自定义比较器对它们进行排序。 编辑：使用lastModified而不是getTotalSpace。

没有真正的“简单方法”可以做到这一点，但也有可能：

List<Path> files = new ArrayList<>();
try(DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
    for(Path p : stream) {
        files.add(p);
    }
}

Collections.sort(files, new Comparator<Path>() {
    public int compare(Path o1, Path o2) {
        try {
            return Files.getLastModifiedTime(o1).compareTo(Files.getLastModifiedTime(o2));
        } catch (IOException e) {
            // handle exception
        }
    }
});

List files=new ArrayList（）；
try（DirectoryStream=Files.newDirectoryStream（dir））{
for（路径p：流）{
添加（p）；
}
}
Collections.sort（文件、新比较器（）{
公共整数比较（路径o1，路径o2）{
试一试{
返回Files.getLastModifiedTime（o1）.compareTo（Files.getLastModifiedTime（o2））；
}捕获（IOE异常）{
//处理异常
}
}
});

---

这将最快对文件进行排序，最后修改文件

DirectoryStream

s不会遍历子目录。

注意：此解决方案需要番石榴

JavaIO/NIOAPI提供了对目录列表的低级访问，但是没有完成任何处理，这将留给调用者。 在访问目录列表进行进一步处理（例如排序）时，新的Java7 NIO DirectoryStream占用的空间最小

以下是我的解决方案：从DirectoryStream读取文件，并从流中构建一个大小（可选）有限的排序队列。从队列中返回最早/最新的元素

private void listFilesOldestFirst(final File directory, final Integer maxNumberOfFiles) {

    final Builder<File> builder =
            MinMaxPriorityQueue
            .orderedBy(LastModifiedFileComparator.LASTMODIFIED_COMPARATOR);
    if( maxNumberOfFiles != null ) {
        builder.maximumSize(maxNumberOfFiles);
    }

    // queue with constant space, if maxNumberOfFiles is set, otherwise behaves like an unbound queue with an O(log n) penalty for insertion
    final MinMaxPriorityQueue<File> oldestFiles = builder.create();

    try(DirectoryStream<Path> stream = Files.newDirectoryStream(directory.toPath())) {
        for(final Path p : stream) {
            oldestFiles.add(p.toFile());
        }
    } catch (final IOException e) {
        throw new RuntimeException(e);
    }

    final File[] fileArray = oldestFiles.toArray(new File[]{});
    Arrays.sort(fileArray, oldestFiles.comparator());
    // ... use fileArray

    final ArrayList<File> arrayList = Lists.newArrayList(oldestFiles);
    Collections.sort(arrayList, oldestFiles.comparator());
    // ... use arrayList

}

private void listFilesOldestFirst（最终文件目录，最终整数maxNumberOfFiles）{
最终建造商=
MinMaxPriorityQueue
.orderedBy（LastModifiedFileComparator.LASTMODIFIED\u COMPARATOR）；
if（maxNumberOfFiles！=null）{
builder.maximumSize（maxNumberOfFiles）；
}
//如果设置了maxNumberOfFiles，则队列具有恒定空间，否则其行为类似于未绑定队列，插入时将受到O（log n）惩罚
final MinMaxPriorityQueue oldestFiles=builder.create（）；
try（DirectoryStream=Files.newDirectoryStream（directory.toPath（）））{
用于（最终路径p：流）{
添加（p.toFile（））；
}
}捕获（最终IOE例外）{
抛出新的运行时异常（e）；
}
最终文件[]fileArray=oldestFiles.toArray（新文件[]{}）；
sort（fileArray，oldestFiles.comparator（））；
//…使用文件数组
final ArrayList ArrayList=Lists.newArrayList（oldestFiles）；
Collections.sort（arrayList，oldestFiles.comparator（））；
//…使用arrayList
}

番石榴MinMaxPriorityQueue和文件比较程序需要这些依赖项：

    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>18.0</version>
    </dependency>
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.4</version>
    </dependency>

番石榴
番石榴
18
公地io
公地io
2.4

您还可能会发现Files.newDirectoryStream的filter参数非常有用：

final Filter sampleFilter=new Filter（）{
@凌驾
公共布尔接受（最终路径条目）引发IOException{
返回true；//请参阅commons io->FileFilterUtils
}
};
...
Files.newDirectoryStream（directory.toPath（），sampleFilter）

杰弗里的答案稍微有点“流”的变化，有些人可能会觉得更容易。张贴完整性

try (DirectoryStream<Path> files = Files.newDirectoryStream(path)) {
    StreamSupport.stream(files.spliterator(), false)
        .sorted((o1, o2) -> {
            try {
                return Files.getLastModifiedTime(o1).compareTo(Files.getLastModifiedTime(o2));
            } catch (IOException ex) {
                ...
            }
        })
        .filter(file -> Files.isRegularFile(file))
        .forEach(file -> {
        });
}

try（DirectoryStream files=files.newDirectoryStream（path））{
StreamSupport.stream（files.spliterator（），false）
.已排序（（o1，o2）->{
试一试{
返回Files.getLastModifiedTime（o1）.compareTo（Files.getLastModifiedTime（o2））；
}捕获（IOEX异常）{
...
}
})
.filter（文件->文件.isRegularFile（文件））
.forEach（文件->{
});
}

谢谢，但是在一个包含100个文件的目录中，我需要获取最旧的文件，只是想知道是否有比手动比较所有lastModified值更好的方法，例如，只传递一个排序选项，然后获取列表的第一个或最后一个条目，取决于排序方向。为了知道哪个文件是最新/最旧的，有必要对所有文件进行循环。就我所知，这就是FileFilter所做的。除了jdevelop的帖子中提到的以外（编辑：可能有很多方法可以实现这一点），唯一的事情就是创建一个比较器，作为

File f=new File（“”）；sort（f.listFiles（），new Comparator（）{public int compare（File o1，File o2）{return（int）（o1.lastModified（）-o2.lastModified（））；}}）；返回f[0]感谢您提供完整的解决方案。File.listFiles（）可能会缩短您的代码：-）@stefan.at.wpf，但它不会按照您的请求使用NIO2。好的，对不起，没有注意到这一点。我不需要NIO，我只是想知道NIO是否能提供一个简单的解决方案；-）请注意，lastModifiedTime的精度可能不足以比较文件。例如，当复制一组文件时，所有目标文件都将具有相同的lastModifiedTime，因此无法按它对其进行排序。发生这种情况是因为lastModifiedTime的精度通常仅设置为秒，而不设置为毫秒。
Collections.sort（files，Comparator.comparingLong（File:：lastModified））为什么标记为重复？这个问题是关于JavaNIO的。这个
    final Filter<Path> sampleFilter = new Filter<Path>() {
        @Override
        public boolean accept(final Path entry) throws IOException {
            return true; // see commons-io -> FileFilterUtils
        }
    };

    ...
    Files.newDirectoryStream(directory.toPath(), sampleFilter)

try (DirectoryStream<Path> files = Files.newDirectoryStream(path)) {
    StreamSupport.stream(files.spliterator(), false)
        .sorted((o1, o2) -> {
            try {
                return Files.getLastModifiedTime(o1).compareTo(Files.getLastModifiedTime(o2));
            } catch (IOException ex) {
                ...
            }
        })
        .filter(file -> Files.isRegularFile(file))
        .forEach(file -> {
        });
}