Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Comparator.thenComparingInt(): aggiungere una chiave secondaria di tipo int

Aggiungi a un comparatore esistente una chiave `int` in ordine crescente. La chiave numerica determina l’ordine solo se il comparatore precedente restituisce `0`.

Versione: Java SE 21

Sintassi

default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor)

Comparator.thenComparingInt() è un metodo di default dell’interfaccia java.util.Comparator, disponibile da Java 8. Restituisce un comparatore composto. Se il comparatore precedente restituisce un valore diverso da 0, quel risultato determina l’ordine. Solo se restituisce 0, il nuovo comparatore confronta le chiavi int in ordine crescente. Chiavi uguali danno 0, ma questo non implica che gli oggetti siano uguali secondo equals().

L’argomento ToIntFunction<? super T> è una funzione il cui tipo di input può essere T o un supertipo di T e che restituisce un int primitivo. Puoi passare un riferimento a metodo come Task::priority o una lambda come task -> task.priority(). A differenza di thenComparing con una funzione che estrae una chiave Comparable, questo metodo non richiede di racchiudere la chiave in un oggetto Integer.

Usa il metodo statico Comparator.comparingInt(...) quando la chiave numerica deve essere il primo criterio. Usa thenComparingInt(...) su un comparatore esistente quando il numero deve solo risolvere le parità. Passare null come funzione di estrazione causa una NullPointerException.

Esempi

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class Main {
    record Task(String team, int priority) {}

    public static void main(String[] args) {
        var tasks = new ArrayList<>(List.of(
                new Task("Ops", 3),
                new Task("Dev", 4),
                new Task("Ops", 1),
                new Task("Dev", 2)
        ));

        Comparator<Task> order = Comparator.comparing(Task::team)
                .thenComparingInt(Task::priority);

        tasks.sort(order);
        for (Task task : tasks) {
            System.out.println(task.team() + " " + task.priority());
        }
    }
}

Risultato

Dev 2
Dev 4
Ops 1
Ops 3

Il nome del team viene confrontato per primo. La priorità è ordinata in senso crescente solo all’interno dello stesso team. Perciò `Dev 4` precede `Ops 1`, anche se `4` è maggiore di `1`.

Lezioni correlate

  • Java · Lezione 61 · Base · Versione: 2

Fonti