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

CKTIS / Java

Comparator — composer des règles de tri

java.util.Comparator décrit un ordre indépendamment de la classe des objets. Il permet de combiner des clés, d’inverser le sens du tri et de traiter explicitement null, aussi bien pour les éléments entiers que pour leurs champs.

Version : Java SE 21; repository runtime, production runtime not attested

Syntaxe

Comparator<T> order = Comparator.comparing(keyExtractor, keyComparator).thenComparingInt(intKeyExtractor);
Comparator<T> descending = order.reversed();
Comparator<T> nullable = Comparator.nullsLast(order);

java.util.Comparator<T> définit un ordre : compare(a, b) renvoie une valeur négative, zéro ou une valeur positive. La comparaison doit être transitive. Permuter les arguments doit inverser le signe d’un résultat non nul ; si compare(a, b) renvoie zéro, compare(b, a) doit aussi renvoyer zéro. Si compare(a, b) renvoie zéro, alors, pour tout z, les résultats de compare(a, z) et de compare(b, z) doivent avoir le même signe : ils doivent être tous deux négatifs, tous deux nuls ou tous deux positifs. Zéro signifie que les éléments sont équivalents selon cet ordre, pas nécessairement selon equals ; dans TreeSet et TreeMap, cela influe sur l’unicité.

Comparator.comparing compare les clés extraites selon leur ordre naturel ou selon un comparateur fourni. Comparator.naturalOrder utilise Comparable et rejette null. Comparator.comparingInt utilise une clé int sans la convertir en Integer.

Comparator.thenComparing ajoute un critère de départage utilisé uniquement en cas d’égalité ; il accepte un comparateur ou un extracteur de clé, éventuellement accompagné d’un comparateur de clé. Comparator.thenComparingInt ajoute une clé int. Comparator.reversed inverse tout l’ordre construit jusque-là : la position de l’appel est donc importante.

Comparator.nullsFirst et Comparator.nullsLast placent respectivement null avant ou après les valeurs non nulles. Envelopper le comparateur de clé protège la clé ; envelopper l’ordre complet protège l’élément. Inverser un comparateur enveloppé inverse aussi la position de null.

Exemples

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    record Item(String name, int score, int id) {}

    public static void main(String[] args) {
        Item[] items = {
            new Item("Ada", 10, 2),
            null,
            new Item(null, 10, 4),
            new Item("Ada", 10, 1),
            new Item("Bob", 20, 3)
        };

        Comparator<Item> byName = Comparator.comparing(
                Item::name,
                Comparator.nullsFirst(Comparator.<String>naturalOrder()));
        Comparator<Item> order = Comparator.comparingInt(Item::score)
                .reversed()
                .thenComparing(byName)
                .thenComparingInt(Item::id);

        Arrays.sort(items, Comparator.nullsLast(order));
        for (Item item : items) {
            System.out.println(item == null ? "null"
                    : item.name() + ":" + item.score() + ":" + item.id());
        }
    }
}

Résultat

Bob:20:3
null:10:4
Ada:10:1
Ada:10:2
null

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources