Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

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

Sources