Iniziamo con qualcosa di veramente elementare, ma ricorrente nelle applicazioni di tutti i giorni: estrarre da una directory, sottodirectory comprese, una lista di file che corrisponde ad un certo pattern. Nel caso in esame tutti i file che iniziano con "aa", ordinarli secondo la data di ultima modifica ed estrarne solo il più recente. Tutto ciò, seguendo passo passo la nostra soluzione funzionale.

String filepath = "./";
Stream<Path> files = Files.find(Paths.get(filepath),
        MAX_VALUE, (path, basicFileAttributes) -> path.toFile().getName().startsWith("aa")
);

La riga di codice riportata sopra ricerca per maxDepth = Integer.MAX_VALUE, cioè, come facile intuire, in profondità per un massimo di MAX_VALUE livelli (un numero veramente grande, quindi di fatto, tutti i livelli possibili che si possano prevedere in un caso come questo), o sub directory.
Il tipo ritornato dalla ricerca è uno stream di oggetti Path, sul quale poi possiamo applicare tutte le operazioni consentite dal contesto, su uno stream.
Dello stream di file ci interessa solo l'elemento più recente, applichiamo quindi il metodo max() passandogli il comparatore più opportuno, costruito con la lambda che ci permette di ordinare rispetto alla data di ultime modifica, è cioè, f -> f.toFile().lastModified(), f è un Path, mentre lastModified è disponibile solo su oggetti di tipo File, ecco il motivo di utilizzare prima il metodo toFile.

Optional<Path> last = files.max(Comparator.comparingLong(f -> f.toFile().lastModified()));

Il metodo max ritorna un Optional, quindi niente null, ma dobbiamo controllare con il metodo isPresent() prima di poter prendere il valore tornato con il metodo get().

if (last.isPresent()) {
    String target = last.get().getFileName().toString();
    System.out.println("The target is: " + target);
}

Vi riporto qui sotto, una piccola variante, la ricerca del file con maggiore dimensione, che rispetta il pattern inizia con "aa", ricerchiamo il file con maggior dimensione (che termina con *.txt, in questo caso).

Comparator<Path> lengthComparator = Comparator.comparingLong(
   f -> f.toFile().length()
);
Optional<Path> maxsize = Files.find(Paths.get("./"),
   MAX_VALUE,
  (path, basicFileAttributes) ->
   path.toFile().getName().endsWith(".txt")
).max(lengthComparator);
if (maxsize.isPresent()) 
   System.out.println("target is:"+
   maxsize.get().getFileName().toString());

Riproponiamo ora la soluzione per la variante che ricerca il file più recente, ma in una veste più compatta, che è quello che si fa normalmente quando si diventa più pratici con stream e lambda:

Optional<Path> lastmod = 
   Files.find(Paths.get(filepath),
      MAX_VALUE, (path, basicFileAttributes)->    
      path.toFile().getName().startsWith("aa")
   ).max(Comparator.comparingLong(f -> f.toFile().lastModified()));
   if (lastmod.isPresent()) {
     Path targetPath = lastmod.get();
   }

Potrei proporre anche una soluzione classica non funzionale per compararla con quella proposta,ma non vogliamo "fare la morte di Violetta", di queste soluzioni ne abbiamo sotto gli occhi tutti i giorni, anche scritte da noi stessi, nulla di cui vergognarsi, non si poteva fare nulla di diverso prima degli stream e le lambda, prima. ...Appunto.