CKTIS / Java
Comparator.comparing — confrontare oggetti in base a una chiave
Crea un comparatore di oggetti a partire da una chiave. Usa l’ordine naturale delle chiavi oppure fornisci un comparatore che stabilisca l’ordine, anche per le chiavi `null`.
Versione: Java SE 21
Sintassi
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)In Java SE 21, Comparator.comparing è un metodo statico dell’interfaccia java.util.Comparator. La notazione Comparator.comparing() indica il metodo in un testo, ma non è una chiamata valida senza argomenti. Il metodo restituisce un Comparator<T> e non ordina nulla da solo. Quando confronta due oggetti di tipo T, il comparatore restituito estrae da ciascuno una chiave di tipo U e confronta le due chiavi.
La variante con un argomento usa l’ordine naturale delle chiavi, quindi U deve implementare Comparable<? super U>. Il riferimento al metodo Ticket::getId estrae la chiave: dato un Ticket, ne restituisce l’identificativo di tipo String. L’ordine naturale di String è lessicografico, non numerico, quindi T10 precede T2.
La variante con due argomenti usa il comparatore fornito per le chiavi e non richiede che U implementi Comparable. In entrambe le varianti, passare null come argomento del metodo provoca una NullPointerException. Una chiave restituita dalla funzione di estrazione è un caso diverso: la variante con un argomento non gestisce le chiavi null. Nella variante con due argomenti, Comparator.nullsLast(Comparator.naturalOrder()) mette le chiavi null dopo le altre. Ciò non protegge da un elemento null nella lista: Ticket::getId proverebbe comunque a chiamare un metodo su null. Se anche gli elementi possono essere null, racchiudi l’intero comparatore di Ticket in Comparator.nullsLast.
Esempi
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);
}
}Risultato
[T10, T2] [T10, T2, null]
È `List.sort` a cambiare l’ordine della lista. Il primo ordinamento usa l’ordine naturale degli identificativi `String`. Prima del secondo viene inserito in testa un `Ticket` con identificativo `null`; il secondo ordinamento lo sposta in fondo.
Lezioni correlate
- Java · Lezione 42 · Base · Versione: 2
- Java · Lezione 48 · Base · Versione: 2
- Java · Lezione 35 · Intermedio · Versione: 2