Best way to list files in Java, sorted by Date Modified?

Decrypting the Jargon

Sorting files by their modification date can get confusing, thanks to Java's dossier of classes and methods. Simplifying things, below are common Java methods to declutter your code.

The Old School Approach : Arrays.sort()

Can't let go of legacy code? Here's an approach using File.listFiles() and Arrays.sort() with a custom Comparator:

File dir = new File("your/directory");
File[] files = dir.listFiles();

Arrays.sort(files, new Comparator<File>() {
    public int compare(File f1, File f2) {
        // Quick, make a wish! Your files are getting sorted.
        return Long.compare(f1.lastModified(), f2.lastModified()); 
    }
});


This does the job, but it feels like we're writing a novel just to say "Hello, World!"

The Java 8 Style : Stream API

Thankfully, Java 8 introduced the lambdas and streams to make our lives easier. Combining this with Comparator.comparingLong(), we can simplify a lot of things:

Path dir = Paths.get("your/directory");
try (Stream<Path> stream = Files.list(dir)) {
    stream.map(Path::toFile)
          .sorted(Comparator.comparingLong(File::lastModified))
          // Woah there! Now we're coding with style!
          .forEach(System.out::println); 
}


Elegance and readability in one go. Isn't this what you came for?

Optimize Into Oblivion : Decorate-Sort-Undecorate Pattern

Performance is key. To up the ante, consider the decorate-sort-undecorate (DSU) pattern, designed to reduce I/O operations:

1. "Decorate" files with their corresponding modified dates.
2. "Sort" the resultant pile according to these modified dates.
3. "Undecorate" by extracting the sorted files.

File dir = new File("your/directory");
File[] files = dir.listFiles();

// Step 1 : Get your makeup kits! We're going to adorn our files.
List<Pair<File, Long>> pairs = Arrays.stream(files)
    .map(file -> Pair.of(file, file.lastModified()))
    .collect(Collectors.toList());

// Step 2 : Time for some action by sorting like there's no tomorrow!
Collections.sort(pairs, Comparator.comparingLong(Pair::getRight)); 

// Step 3 : Okay folks, take off the makeup. Leave only sorted file behind.
File[] sortedFiles = pairs.stream()
    .map(Pair::getLeft)
    .toArray(File[]::new);


This DSU strategy optimizes performance by reducing the running time. If you're dealing with a large file system or network attached storage, you'll see the difference!

Preemptive Mitigation

Weight of File I/O

I/O operations can get expensive. Fetch the last-modified time once and reapply where required to improve efficiency.

Consistency of Time Stamps

File time stamps can vary due to resolution limits or system clock changes. Using File API ensures consistency by keeping a standard time.

Handling File Size Surge

When faced with large directories, go for lazily-evaluated stream functions with a java Stream. This keeps memory usage in check.

Upside-down Sorting

To downdate things or sort files in reverse order, add a .reversed() to the Comparator:

files.stream().sorted(Comparator.comparingLong(File::lastModified).reversed());


Directory Accessibility Matters

Before sorting files, always verify the directory is available. Keeps those notorious runtime exceptions at bay!