KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Comparator — sorteervoorwaarden combineren

java.util.Comparator beschrijft een volgorde, onafhankelijk van de klasse van de objecten. Hiermee kun je sleutels combineren, de richting omkeren en null expliciet afhandelen, zowel voor volledige elementen als voor hun velden.

Versie: 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> definieert een volgorde: compare(a, b) geeft een negatieve waarde, nul of een positieve waarde terug. De vergelijking moet transitief zijn. Bij het omwisselen van de argumenten moet een resultaat dat niet nul is van teken veranderen. Geeft compare(a, b) nul terug, dan moet compare(b, a) ook nul teruggeven. Geeft compare(a, b) nul terug, dan moeten de resultaten van compare(a, z) en compare(b, z) voor elke z hetzelfde teken hebben: beide negatief, beide nul of beide positief. Nul betekent gelijkwaardig binnen deze volgorde, niet noodzakelijk volgens equals; in TreeSet en TreeMap heeft dit invloed op de uniciteit.

Comparator.comparing vergelijkt geëxtraheerde sleutels volgens hun natuurlijke volgorde of een opgegeven comparator. Comparator.naturalOrder gebruikt Comparable en weigert null. Comparator.comparingInt gebruikt een int-sleutel zonder deze naar Integer om te zetten.

Comparator.thenComparing voegt een criterium toe dat alleen bij gelijke waarden wordt gebruikt; het accepteert een comparator of een sleutel-extractor, eventueel met een comparator voor de sleutel. Comparator.thenComparingInt voegt een int-sleutel toe. Comparator.reversed keert de volledige volgorde die tot dan toe is opgebouwd om, dus de plaats van de aanroep is belangrijk.

Comparator.nullsFirst en Comparator.nullsLast plaatsen null respectievelijk vóór of na niet-null-waarden. De sleutelcomparator omhullen beschermt de sleutel; de volledige volgorde omhullen beschermt het element. Een omhulde comparator omkeren verandert ook de positie van null.

Voorbeelden

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

Resultaat

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

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen