在长长的文件列表中查找最近修改的 3 个文件

Question

我有一个文件列表，我想对其进行排序并提取最后修改的前 3 个文件。

约束：由于下游应用程序的兼容性问题，我无法使用 Java 7

我目前的选择

解决方案 1

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

解决方案 2

public static void sortFilesDesc(File[] files) {
  Arrays.sort(files, new Comparator() {
    public int compare(Object o1, Object o2) {
      if ((File)o1).lastModified().compareTo((File)o2).lastModified()) {
        return -1;
      } else if (((File) o1).lastModified() < ((File) o2).lastModified()) {
        return +1;
      } else {
        return 0;
      }
    }
  });
}

问题

以上两个解决方案需要更多的时间来执行和内存。我的文件列表包含大约 300 个 tar 文件，每个文件大小为 200MB。所以它会消耗更多的时间和内存。

有什么方法可以有效地处理这个问题吗？

每个比较操作都使用一个高内存的文件对象，有什么办法可以释放内存并有效地处理这个问题？

Answer 1

你可以做得更快。

Arrays.sort(...) 使用“快速排序”，它需要 ~ n * ln(n) 操作。

这个例子只对整个数组进行一次迭代，即 ~ n 次操作。

public static void sortFilesDesc(File[] files) {        
    File firstMostRecent = null;
    File secondMostRecent = null;
    File thirdMostRecent = null;
    for (File file : files) {
        if ((firstMostRecent == null)
                || (firstMostRecent.lastModified() < file.lastModified())) {
            thirdMostRecent = secondMostRecent;
            secondMostRecent = firstMostRecent;             
            firstMostRecent = file;
        } else if ((secondMostRecent == null)
                || (secondMostRecent.lastModified() < file.lastModified())) {
            thirdMostRecent = secondMostRecent;
            secondMostRecent = file;
        } else if ((thirdMostRecent == null)
                || (thirdMostRecent.lastModified() < file.lastModified())) {
            thirdMostRecent = file;
        }
    }
} 

对于少量文件，您不会看到太大差异，但即使对于数十个文件，差异也会很显着，对于较大数量的文件 - 戏剧性。

检查算法的代码（请输入正确的文件结构）：

package com.hk.basicjava.clasload.tests2;

import java.io.File;
import java.util.Date;


class MyFile extends File {

    private long time = 0; 

    public MyFile(String name, long timeMills) {
        super(name);
        time = timeMills;
    }
    @Override
    public long lastModified() {
        return time;
    }
}

public class Files {

    /**
     * @param args
     */
    public static void main(String[] args) {

        File[] files = new File[5]; 
        files[0] = new MyFile("File1", new Date(2013,1,15, 7,0).getTime());
        files[1] = new MyFile("File2", new Date(2013,1,15, 7,40).getTime());
        files[2] = new MyFile("File3", new Date(2013,1,15, 5,0).getTime());
        files[3] = new MyFile("File4", new Date(2013,1,15, 10,0).getTime());
        files[4] = new MyFile("File5", new Date(2013,1,15, 4,0).getTime());
        sortFilesDesc(files);
    }

    public static void sortFilesDesc(File[] files) {        
        File firstMostRecent = null;
        File secondMostRecent = null;
        File thirdMostRecent = null;
        for (File file : files) {
            if ((firstMostRecent == null)
                    || (firstMostRecent.lastModified() < file.lastModified())) {
                thirdMostRecent = secondMostRecent;
                secondMostRecent = firstMostRecent;             
                firstMostRecent = file;
            } else if ((secondMostRecent == null)
                    || (secondMostRecent.lastModified() < file.lastModified())) {
                thirdMostRecent = secondMostRecent;
                secondMostRecent = file;
            } else if ((thirdMostRecent == null)
                    || (thirdMostRecent.lastModified() < file.lastModified())) {
                thirdMostRecent = file;
            }
        }
        System.out.println("firstMostRecent : " + firstMostRecent.getName());
        System.out.println("secondMostRecent : " + secondMostRecent.getName());
        System.out.println("thirdMostRecent : " + thirdMostRecent.getName());
    } 

}

Answer 2

你必须检查每个文件的 lastModified，你不能改变它。您不需要做的就是对所有元素进行排序以获得前 3 个。如果您可以使用 Guava，您可以使用Ordering.greatestOf（使用了一个很好的算法）：

Ordering<File> ordering = Ordering.from( new Comparator(){
        public int compare(File f1, File f2)
        {
            return Long.valueOf(f1.lastModified()).compareTo(f2.lastModified());
        });

List<File> max3 = ordering.greatestOf(Arrays.asList(directory.listFiles()), 3);

Answer 3

我支持解决方案 1，但有一些改进

Arrays.sort(files, new Comparator<File>() {
        public int compare(File f1, File f2) {
            long d1 = f1.lastModified();
            long d2 = f2.lastModified();
            return d1 > d2 ? 1 : d1 < d2 ? -1 : 0;
        }
    });

避免由于 Long.valueOf(long) 而创建不必要的对象。

File 不保存/读取任何文件数据，只保存文件路径，不存在性能/内存问题。这里唯一耗时的操作是从文件系统中读取修改时间，这是无法避免的。

Answer 4

您的问题是检索上次修改日期是一项相对昂贵的操作，因为它涉及操作系统逻辑。因此，如果您不介意获取最新的值，您可以将文件包装在一个可比较的类中。

public class LastModifiedFile implements Comparable<LastModifiedFile> {

    private final File file;
    private final Date lastModified;

    public LastModifiedFile(File file) {
        this.file = file;
        lastModified = file.lastModified();
    }

    public int compareTo(LastModifiedFile other) {
        return lastModified.compareTo(other.lastModified);
    }
}

请注意，在排序期间更改上次修改日期将导致许多排序算法出现未定义的行为。如果最后修改日期发生更改，Java 7s Tim Sort 实现将抛出异常，因此比较会导致不同的值。