CKTIS / Java
Comparator.comparing — comparer des objets selon une clé
Créez un comparateur d’objets à partir d’une clé. Utilisez l’ordre naturel des clés ou fournissez un comparateur qui précise notamment où placer les clés `null`.
Version : Java SE 21
Syntaxe
import java.util.Comparator;
import java.util.function.Function;
// Static method signatures on java.util.Comparator (Java SE 21)
static <T, U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor)
static <T, U> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator)Dans Java SE 21, Comparator.comparing est une méthode statique de l’interface java.util.Comparator. La notation Comparator.comparing() désigne la méthode dans un texte ; ce n’est pas un appel valide sans argument. La méthode renvoie un Comparator<T> et ne trie rien elle-même. Lorsqu’il compare deux objets de type T, le comparateur renvoyé extrait de chacun une clé de type U, puis compare ces clés.
La surcharge à un argument suit l’ordre naturel des clés : U doit donc implémenter Comparable<? super U>. La référence de méthode Ticket::getId sert à extraire la clé : pour un Ticket donné, elle renvoie son identifiant de type String. L’ordre naturel de String est lexicographique, et non numérique : T10 précède donc T2.
La surcharge à deux arguments utilise le comparateur fourni pour comparer les clés et n’impose pas à U d’implémenter Comparable. Dans les deux surcharges, passer null comme argument de la méthode déclenche une NullPointerException. Une clé renvoyée par la fonction d’extraction est un cas distinct : la surcharge à un argument ne gère pas les clés null. Avec la surcharge à deux arguments, Comparator.nullsLast(Comparator.naturalOrder()) place les clés null après les autres. Cela ne protège pas contre un élément null dans la liste : Ticket::getId tenterait toujours d’appeler une méthode sur null. Si les éléments peuvent aussi être null, enveloppez le comparateur de Ticket tout entier dans Comparator.nullsLast.
Exemples
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.StringJoiner;
public class Main {
static final class Ticket {
private final String id;
Ticket(String id) {
this.id = id;
}
String getId() {
return id;
}
}
private static void printIds(List<Ticket> tickets) {
StringJoiner ids = new StringJoiner(", ", "[", "]");
for (Ticket ticket : tickets) {
ids.add(String.valueOf(ticket.getId()));
}
System.out.println(ids.toString());
}
public static void main(String[] args) {
List<Ticket> tickets = new ArrayList<>(List.of(
new Ticket("T2"), new Ticket("T10")));
Comparator<Ticket> byId = Comparator.comparing(Ticket::getId);
tickets.sort(byId);
printIds(tickets);
tickets.add(0, new Ticket(null));
Comparator<Ticket> byIdNullsLast = Comparator.comparing(
Ticket::getId, Comparator.nullsLast(Comparator.naturalOrder()));
tickets.sort(byIdNullsLast);
printIds(tickets);
}
}Résultat
[T10, T2] [T10, T2, null]
C’est `List.sort` qui modifie l’ordre de la liste. Le premier tri utilise l’ordre naturel des identifiants `String`. Avant le second tri, un `Ticket` dont l’identifiant vaut `null` est inséré au début de la liste ; le second tri le déplace à la fin.
Leçons associées
- Java · Leçon 42 · Débutant · Version : 2
- Java · Leçon 48 · Débutant · Version : 2
- Java · Leçon 35 · Intermédiaire · Version : 2