CKTIS / Java
Comparator.thenComparing — aggiungere un criterio per risolvere le parità
Combina più criteri di ordinamento in modo che il successivo intervenga solo quando i precedenti non distinguono due elementi.
Versione: Java SE 21
Sintassi
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 indica una famiglia di metodi predefiniti di java.util.Comparator, disponibili da Java 8 e inclusi in Java SE 21. Comparator.thenComparing() è una notazione abbreviata per indicare il metodo, non un overload senza argomenti. La chiamata su un comparatore esistente restituisce un comparatore composto. Il comparatore originale non cambia e la chiamata stessa non ordina nulla.
Per una coppia a e b, si usa il criterio successivo solo se il compare(a, b) del comparatore corrente restituisce 0. È una parità secondo il comparatore, non necessariamente un’uguaglianza secondo equals. In una catena, il terzo criterio interviene solo se i primi due danno parità. Se tutti i criteri danno parità, il comparatore composto restituisce 0 e l’ordinamento stabile di List.sort conserva l’ordine relativo della coppia.
thenComparing(other) delega il confronto degli stessi elementi a un altro comparatore. thenComparing(keyExtractor) estrae una chiave Comparable da ciascun elemento e confronta le chiavi secondo il loro ordine naturale. thenComparing(keyExtractor, keyComparator) confronta le chiavi estratte con il comparatore fornito; non è necessario che le chiavi implementino Comparable.
Passare null come argomento provoca una NullPointerException. È un caso diverso da una chiave null restituita dalla funzione di estrazione: l’overload che usa l’ordine naturale non gestisce queste chiavi. Se sono possibili, si può fornire come comparatore delle chiavi, ad esempio, Comparator.nullsLast(Comparator.naturalOrder()). Per le chiavi primitive, thenComparingInt, thenComparingLong e thenComparingDouble evitano il boxing.
Esempi
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());
}
}
}Risultato
21 Brown 21 Smith 30 Adams
`Comparator.comparingInt(Person::age)` ordina le persone per età crescente. `Person::lastName` risolve la parità tra le due persone di 21 anni: Brown precede Smith. Adams viene per ultimo per via dell’età, anche se nell’ordine naturale delle stringhe Adams verrebbe per primo.
Lezioni correlate
- Java · Lezione 8 · Avanzato · Versione: 2
- Java · Lezione 48 · Base · Versione: 2
- Java · Lezione 35 · Intermedio · Versione: 2