Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / Java

Comparator — sestavljanje pravil urejanja

java.util.Comparator opisuje vrstni red neodvisno od razreda objektov. Omogoča združevanje ključev, obrat smeri in izrecno obravnavo null tako za celotne elemente kot za njihova polja.

Različica: Java SE 21; repository runtime, production runtime not attested

Sintaksa

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

java.util.Comparator<T> določa vrstni red: compare(a, b) vrne negativno vrednost, nič ali pozitivno vrednost. Primerjava mora biti tranzitivna. Ob zamenjavi argumentov se mora predznak neničelnega rezultata obrniti. Če compare(a, b) vrne nič, mora tudi compare(b, a) vrniti nič. Če compare(a, b) vrne nič, morata imeti rezultata compare(a, z) in compare(b, z) za vsak z enak predznak: oba morata biti negativna, oba enaka nič ali oba pozitivna. Nič pomeni enakovrednost v tem vrstnem redu, ne nujno equals; v TreeSet in TreeMap to vpliva na enoličnost.

Comparator.comparing primerja izluščene ključe po njihovem naravnem vrstnem redu ali po podanem primerjalniku. Comparator.naturalOrder uporablja Comparable in zavrne null. Comparator.comparingInt uporablja ključ int brez pretvorbe v Integer.

Comparator.thenComparing doda dodatno merilo, ki se uporabi samo ob izenačenju; sprejme primerjalnik ali izvleček ključa, po želji s primerjalnikom ključa. Comparator.thenComparingInt doda ključ int. Comparator.reversed obrne celoten do takrat sestavljeni vrstni red, zato je mesto klica pomembno.

Comparator.nullsFirst in Comparator.nullsLast postavita null pred vrednosti, ki niso null, oziroma za njimi. Ovoj primerjalnika ključa zaščiti ključ; ovoj celotnega vrstnega reda zaščiti element. Obrat ovitega primerjalnika obrne tudi položaj null.

Primeri

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

Rezultat

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

Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.

Viri