Comment utiliser un lambda Java8 pour sortinger un stream dans l’ordre inverse?

J’utilise java lambda pour sortinger une liste.

Comment puis-je le sortinger de manière inverse?

J’ai vu ce post , mais je veux utiliser java 8 lambda.

Voici mon code (j’ai utilisé * -1) comme un hack

Arrays.asList(files).stream() .filter(file -> isNameLikeBaseLine(file, baseLineFile.getName())) .sorted(new Comparator() { public int compare(File o1, File o2) { int answer; if (o1.lastModified() == o2.lastModified()) { answer = 0; } else if (o1.lastModified() > o2.lastModified()) { answer = 1; } else { answer = -1; } return -1 * answer; } }) .skip(numOfNewestToLeave) .forEach(item -> item.delete()); 

Vous pouvez adapter la solution que vous avez liée dans Comment sortinger ArrayList dans Java par ordre décroissant? en l’enveloppant dans un lambda:

.sorted((f1, f2) -> Long.compare(f2.lastModified(), f1.lastModified())

notez que f2 est le premier argument de Long.compare , pas le second, le résultat sera donc inversé.

BTW: si vos éléments de stream implémentent Comparable alors c’est devenu simple:

  ...stream() .sorted(Comparator.reverseOrder()) 

Utilisation

 Comparator comparator = Comparator.comparing(File::lastModified); Collections.sort(list, comparator .reversed()); 

alors

 .forEach(item -> item.delete()); 

Vous pouvez utiliser une référence de méthode:

 import static java.util.Comparator.*; import static java.util.stream.Collectors.*; Arrays.asList(files).stream() .filter(file -> isNameLikeBaseLine(file, baseLineFile.getName())) .sorted(comparing(File::lastModified).reversed()) .skip(numOfNewestToLeave) .forEach(item -> item.delete()); 

En alternative à la référence de méthode, vous pouvez utiliser une expression lambda, l’argument de comparaison devenant ainsi:

 .sorted(comparing(file -> file.lastModified()).reversed()); 

Partage de manière alternative:

ASC

 List animals = this.service.findAll(); animals = animals.stream().sorted(Comparator.comparing(Animal::getName)).collect(Collectors.toList()); 

DESC

 List animals = this.service.findAll(); animals = animals.stream().sorted(Comparator.comparing(Animal::getName).reversed()).collect(Collectors.toList()); 

Cela peut facilement être fait en utilisant Java 8 et l’utilisation d’un comparateur inversé.

J’ai créé une liste de fichiers à partir d’un répertoire, que je affiche non sortingés, sortingés et sortingés en arrière à l’aide d’un simple comparateur pour le sorting, puis en appelant inversé () pour obtenir la version inversée de ce comparateur.

Voir le code ci-dessous:

 package test; import java.io.File; import java.util.Arrays; import java.util.Comparator; import java.util.Date; import java.util.List; import java.util.stream.Collectors; public class SortTest { public static void main(Ssortingng... args) { File directory = new File("C:/Media"); File[] files = directory.listFiles(); List filesList = Arrays.asList(files); Comparator comparator = Comparator.comparingLong(File::lastModified); Comparator reverseComparator = comparator.reversed(); List forwardOrder = filesList.stream().sorted(comparator).collect(Collectors.toList()); List reverseOrder = filesList.stream().sorted(reverseComparator).collect(Collectors.toList()); System.out.println("*** Unsorted ***"); filesList.forEach(SortTest::processFile); System.out.println("*** Sort ***"); forwardOrder.forEach(SortTest::processFile); System.out.println("*** Reverse Sort ***"); reverseOrder.forEach(SortTest::processFile); } private static void processFile(File file) { try { if (file.isFile()) { System.out.println(file.getCanonicalPath() + " - " + new Date(file.lastModified())); } } catch (Exception e) { System.out.println(e.getMessage()); } } }