Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / Java

Comparator — skladanie pravidiel usporiadania

java.util.Comparator opisuje poradie nezávisle od triedy objektov. Umožňuje kombinovať kľúče, obrátiť smer a výslovne ošetriť null, a to pri celých prvkoch aj pri ich poliach.

Verzia: Java SE 21; repository runtime, production runtime not attested

Syntax

Comparator<T> order = Comparator.comparing(keyExtractor, keyComparator).thenComparingInt(intKeyExtractor);
Comparator<T> descending = order.reversed();
Comparator<T> nullable = Comparator.nullsLast(order);

java.util.Comparator<T> definuje poradie: compare(a, b) vracia zápornú hodnotu, nulu alebo kladnú hodnotu. Porovnanie musí byť tranzitívne. Pri zámene argumentov musí nenulový výsledok zmeniť znamienko. Ak compare(a, b) vráti nulu, musí nulu vrátiť aj compare(b, a). Ak compare(a, b) vráti nulu, výsledky compare(a, z) a compare(b, z) musia mať pre každé z rovnaké znamienko: oba musia byť záporné, oba nulové alebo oba kladné. Nula znamená ekvivalenciu v tomto poradí, nie nevyhnutne equals; v TreeSet a TreeMap to ovplyvňuje jedinečnosť.

Comparator.comparing porovnáva extrahované kľúče podľa ich prirodzeného poradia alebo podľa odovzdaného komparátora. Comparator.naturalOrder používa Comparable a odmieta null. Comparator.comparingInt používa kľúč int bez konverzie na Integer.

Comparator.thenComparing pridáva rozlišovacie kritérium, ktoré sa použije iba pri zhode; prijíma komparátor alebo extraktor kľúča, prípadne s komparátorom kľúča. Comparator.thenComparingInt pridáva kľúč int. Comparator.reversed obracia celé poradie zostavené do daného okamihu, preto záleží na umiestnení volania.

Comparator.nullsFirst a Comparator.nullsLast umiestňujú null pred hodnoty, ktoré nie sú null, alebo za ne. Zabalenie komparátora kľúča chráni kľúč; zabalenie celého poradia chráni prvok. Obrátenie zabaleného komparátora obráti aj pozíciu null.

Príklady

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    record Item(String name, int score, int id) {}

    public static void main(String[] args) {
        Item[] items = {
            new Item("Ada", 10, 2),
            null,
            new Item(null, 10, 4),
            new Item("Ada", 10, 1),
            new Item("Bob", 20, 3)
        };

        Comparator<Item> byName = Comparator.comparing(
                Item::name,
                Comparator.nullsFirst(Comparator.<String>naturalOrder()));
        Comparator<Item> order = Comparator.comparingInt(Item::score)
                .reversed()
                .thenComparing(byName)
                .thenComparingInt(Item::id);

        Arrays.sort(items, Comparator.nullsLast(order));
        for (Item item : items) {
            System.out.println(item == null ? "null"
                    : item.name() + ":" + item.score() + ":" + item.id());
        }
    }
}

Výsledok

Bob:20:3
null:10:4
Ada:10:1
Ada:10:2
null

Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.

Zdroje