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

CKTIS / Java

Comparator : priorité décroissante, puis numéro de séquence croissant

Triez les tâches par priorité décroissante, puis départagez-les par numéro de séquence croissant. Voyez où placer `reversed()` et comment préciser l’argument de type `<Task>`.

Version : Java SE 21

Syntaxe

Comparator<Task> order = Comparator.<Task>comparingInt(Task::priority)
    .reversed()
    .thenComparingLong(Task::seq);

Dans java.util.Comparator, la méthode statique générique comparingInt accepte une ToIntFunction<? super T> et construit un comparateur qui ordonne selon une clé int par ordre croissant. Dans Comparator.<Task>comparingInt(Task::priority), l’argument de type explicite <Task>, appelé type witness en anglais, fixe T à Task dès cet appel. Il est facultatif si le compilateur peut inférer le type.

La méthode par défaut reversed() renvoie un comparateur à l’ordre inverse. Appelez-la avant d’ajouter la seconde clé pour n’inverser que l’ordre des priorités. Déplacer cet appel à la fin inverserait l’ordre d’un comparateur qui trie les deux clés par ordre croissant : la priorité et seq seraient alors toutes deux triées par ordre décroissant.

La méthode par défaut thenComparingLong accepte une ToLongFunction<? super T> et compare la clé long par ordre croissant uniquement si le comparateur précédent renvoie 0. Les clés int et long ne nécessitent pas de conversion par boxing en Integer ou Long. Si les deux clés sont égales, la comparaison renvoie 0, sans que equals doive nécessairement renvoyer true.

Exemples

import java.util.Comparator;
import java.util.stream.Stream;

public class Main {
    record Task(String name, int priority, long seq) {}

    public static void main(String[] args) {
        Comparator<Task> order = Comparator.<Task>comparingInt(Task::priority)
            .reversed()
            .thenComparingLong(Task::seq);

        Stream.of(
                new Task("low", 1, 1L),
                new Task("later", 5, 3_000_000_002L),
                new Task("earlier", 5, 3_000_000_001L))
            .sorted(order)
            .map(Task::name)
            .forEachOrdered(System.out::println);
    }
}

Résultat

earlier
later
low

`forEachOrdered` affiche les noms dans l’ordre du tri. `earlier` précède `later` car son `seq` est plus petit ; `low` arrive en dernier malgré le plus petit `seq`, car sa priorité est plus faible.

Leçons associées

  • Java · Leçon 38 · Avancé · Version : 2

Sources