在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());
} });
243483 次浏览
小开
最佳答案

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

小开

你也可以看看apache commons IO，它有一个内置的最后修改比较器和许多其他很好的实用程序来处理文件。

小开

如果您有很多文件，这可能会更快。它使用装饰-排序-不装饰模式，以便每个文件的最后修改日期只获取一次，而不是每次排序算法比较两个文件时都获取。这可能会将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;
小开 
public String[] getDirectoryList(String path) {
String[] dirListing = null;
File dir = new File(path);
dirListing = dir.list();


Arrays.sort(dirListing, 0, dirListing.length);
return dirListing;
}
小开

你可以试试番石榴订购:

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 +

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

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

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

注意:我知道你可以通过在排序流操作中使用文件:getLastModifiedTime api来避免上面例子中的File对象之间的转换，但是，然后你需要在lambda中处理检查过的IO异常，这总是一个痛苦的问题。我想说，如果性能足够关键，翻译是不可接受的，那么我要么处理lambda中的checkedIOException，将其传播为UncheckedIOException，要么我将放弃Files api，只处理File对象:

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

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

你可以使用Apache LastModifiedFileComparator库

 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

Apache Commons

代码:

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


}
小开

在Java 8中:

Arrays.sort(files, (a, b) -> Long.compare(a.lastModified(), b.lastModified()));

小开

我来到这个帖子时，我正在搜索相同的问题，但在android。 我并不是说这是按最后修改日期排序文件的最佳方法，但它是我迄今为止发现的最简单的方法

下面的代码可能对某人有帮助-

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

自Java 8以来的优雅解决方案:

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

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

小开

还有一种完全不同的方法可能更简单，因为我们不处理大数。

在检索到所有文件名和lastModified日期之后，不必对整个数组进行排序，只需在检索到每个文件名之后在列表的正确位置插入它。

你可以这样做:

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

将object2添加到位置2后，它将把object3移动到位置3。

小开

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

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

小开

@jason-orendorf的回答的稍微现代化的版本。

注意:这个实现保留原始数组没有，并返回一个新数组。这可能是可取的，也可能不是。

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

但是同样，所有的功劳都要归功于@jason-orendorf的的想法!

小开

这里是Kotlin的方法，如果有人正在寻找它:

val filesList = directory.listFiles()


filesList?.let{ list ->
Arrays.sort(list) {
f1, f2 -> f2.lastModified().compareTo(f1.lastModified())
}
}
小开

让数组命名为->文件。

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


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

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

提交答案