KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Comparator: aflopende prioriteit, daarna oplopend volgnummer

Sorteer taken van hoge naar lage prioriteit en zet bij gelijke prioriteit het laagste volgnummer eerst. Bekijk waar `reversed()` hoort en hoe je `<Task>` expliciet meegeeft.

Versie: Java SE 21

Syntax

Comparator<Task> order = Comparator.<Task>comparingInt(Task::priority)
    .reversed()
    .thenComparingLong(Task::seq);

De statische generieke methode comparingInt van java.util.Comparator neemt een ToIntFunction<? super T> aan en maakt een comparator die oplopend sorteert op een int-sleutel. In Comparator.<Task>comparingInt(Task::priority) legt het expliciete typeargument <Task>, ook wel een type witness, T bij die aanroep vast als Task. Kan de compiler het type afleiden, dan is dit argument optioneel.

De defaultmethode reversed() retourneert een comparator met de omgekeerde volgorde. Roep deze aan vóór het toevoegen van de tweede sleutel, zodat alleen de prioriteitsvolgorde omkeert. Verplaats je de aanroep naar het eind, dan keer je de volgorde om van een comparator die op beide sleutels oplopend sorteert. Zowel de prioriteit als seq wordt dan aflopend gesorteerd.

De defaultmethode thenComparingLong neemt een ToLongFunction<? super T> aan en vergelijkt de long-sleutel oplopend, maar alleen als de voorgaande comparator 0 retourneert. De int- en long-sleutels hoeven niet te worden geboxed naar Integer of Long. Zijn beide sleutels gelijk, dan retourneert de vergelijking 0; dat betekent niet dat equals ook true moet retourneren.

Voorbeelden

import java.util.Comparator;
import java.util.stream.Stream;

public class Main {
    record Task(String name, int priority, long seq) {}

    public static void main(String[] args) {
        Comparator<Task> order = Comparator.<Task>comparingInt(Task::priority)
            .reversed()
            .thenComparingLong(Task::seq);

        Stream.of(
                new Task("low", 1, 1L),
                new Task("later", 5, 3_000_000_002L),
                new Task("earlier", 5, 3_000_000_001L))
            .sorted(order)
            .map(Task::name)
            .forEachOrdered(System.out::println);
    }
}

Resultaat

earlier
later
low

`forEachOrdered` drukt de namen in gesorteerde volgorde af. `earlier` staat vóór `later` vanwege de kleinere `seq`; `low` staat ondanks de kleinste `seq` achteraan omdat die taak een lagere prioriteit heeft.

Gerelateerde lessen

  • Java · Les 38 · Gevorderd · Versie: 2

Bronnen