CKTIS / Java
Comparator.thenComparing — ajouter un critère de départage
Combinez les critères de tri pour que le suivant n’intervienne que si les précédents ne permettent pas de départager deux éléments.
Version : Java SE 21
Syntaxe
import java.util.Comparator;
import java.util.function.Function;
// Signatures of the default methods on Comparator<T>:
default Comparator<T> thenComparing(Comparator<? super T> other)
default <U extends Comparable<? super U>> Comparator<T> thenComparing(Function<? super T, ? extends U> keyExtractor)
default <U> Comparator<T> thenComparing(Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator)
// Example call on a Comparator<Person>:
byAge.thenComparing(Person::lastName)Comparator.thenComparing désigne plusieurs méthodes par défaut de java.util.Comparator, disponibles depuis Java 8 et présentes dans Java SE 21. Comparator.thenComparing() est une notation abrégée pour désigner la méthode, pas une surcharge sans argument. L’appel sur un comparateur existant renvoie un comparateur composé. Il ne modifie pas le comparateur d’origine et ne trie rien par lui-même.
Pour une paire a et b, le critère suivant ne s’applique que si le comparateur courant renvoie 0 pour compare(a, b). Les éléments sont à égalité pour ce comparateur, mais pas forcément selon equals. Dans une chaîne, le troisième critère ne sert que si les deux premiers donnent une égalité. Si tous les critères donnent une égalité, le comparateur composé renvoie 0 et le tri stable de List.sort conserve l’ordre relatif de la paire.
thenComparing(other) confie la comparaison des mêmes éléments à un autre comparateur. thenComparing(keyExtractor) extrait de chaque élément une clé Comparable et compare les clés dans leur ordre naturel. thenComparing(keyExtractor, keyComparator) compare les clés extraites avec le comparateur fourni ; elles n’ont pas à implémenter Comparable.
Passer null à la place de n’importe quel argument déclenche une NullPointerException. Une clé null renvoyée par la fonction d’extraction est un autre cas : la surcharge qui utilise l’ordre naturel ne gère pas ces clés. Si elles sont possibles, vous pouvez fournir un comparateur de clés tel que Comparator.nullsLast(Comparator.naturalOrder()). Pour les clés de type primitif, thenComparingInt, thenComparingLong et thenComparingDouble évitent le boxing.
Exemples
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
public class Main {
record Person(int age, String lastName) {}
public static void main(String[] args) {
List<Person> people = new ArrayList<>(List.of(
new Person(21, "Smith"),
new Person(30, "Adams"),
new Person(21, "Brown")
));
Comparator<Person> byAge = Comparator.comparingInt(Person::age);
Comparator<Person> byAgeThenLastName = byAge.thenComparing(Person::lastName);
people.sort(byAgeThenLastName);
for (Person person : people) {
System.out.println(person.age() + " " + person.lastName());
}
}
}Résultat
21 Brown 21 Smith 30 Adams
`Comparator.comparingInt(Person::age)` classe les personnes par âge croissant. `Person::lastName` départage les deux personnes de 21 ans : Brown précède Smith. Adams vient en dernier à cause de son âge, même si Adams viendrait en premier dans l’ordre naturel des chaînes.
Leçons associées
- Java · Leçon 8 · Avancé · Version : 2
- Java · Leçon 48 · Débutant · Version : 2
- Java · Leçon 35 · Intermédiaire · Version : 2