Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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

Fonti