Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

Comparator.comparing — porovnávání objektů podle klíče

Vytvořte komparátor objektů podle vybraného klíče. Použijte přirozené pořadí klíčů, nebo dodejte vlastní komparátor, který určí i umístění klíčů `null`.

Verze: 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)

V Java SE 21 je Comparator.comparing statická metoda rozhraní java.util.Comparator. Zápis Comparator.comparing() v textu označuje metodu, nejde však o platné volání bez argumentů. Metoda vrací Comparator<T> a sama nic neřadí. Při porovnávání dvou objektů typu T vrácený komparátor z každého získá klíč typu U a tyto klíče porovná.

Přetížená varianta s jedním argumentem používá přirozené pořadí klíčů, takže U musí implementovat Comparable<? super U>. Odkaz na metodu Ticket::getId slouží k získání klíče: pro daný objekt Ticket vrátí jeho identifikátor typu String. Přirozené pořadí typu String je lexikografické, nikoli číselné, takže T10 je před T2.

Varianta se dvěma argumenty porovnává klíče pomocí předaného komparátoru a nevyžaduje, aby U implementoval Comparable. U obou variant vyvolá předání null jako argumentu metody výjimku NullPointerException. Klíč vrácený funkcí je jiný případ: varianta s jedním argumentem klíče null nezpracuje. U varianty se dvěma argumenty zařadí Comparator.nullsLast(Comparator.naturalOrder()) klíče null za ostatní. To však nechrání před prvkem null v seznamu: Ticket::getId by se stále pokusil zavolat metodu na null. Pokud mohou být null i samotné prvky, předejte do Comparator.nullsLast celý komparátor objektů Ticket.

Příklady

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);
    }
}

Výsledek

[T10, T2]
[T10, T2, null]

Pořadí prvků mění `List.sort`. První řazení používá přirozené pořadí identifikátorů typu `String`. Před druhým řazením se na začátek přidá `Ticket` s identifikátorem `null`; druhé řazení ho přesune na konec.

Související lekce

  • Java · Lekce 42 · Základní · Verze: 2
  • Java · Lekce 48 · Základní · Verze: 2
  • Java · Lekce 35 · Středně pokročilá · Verze: 2

Zdroje