CKTIS / Java
Comparator — Sortierregeln kombinieren
java.util.Comparator beschreibt eine Reihenfolge unabhängig von der Klasse der Objekte. Damit lassen sich Schlüssel kombinieren, die Richtung umkehren und null-Werte sowohl für ganze Elemente als auch für ihre Felder ausdrücklich behandeln.
Version: 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> definiert eine Reihenfolge: compare(a, b) gibt einen negativen Wert, 0 oder einen positiven Wert zurück. Der Vergleich muss transitiv sein. Beim Vertauschen der Argumente muss sich das Vorzeichen eines von 0 verschiedenen Ergebnisses umkehren. Gibt compare(a, b) den Wert 0 zurück, muss auch compare(b, a) den Wert 0 zurückgeben. Gibt compare(a, b) den Wert 0 zurück, müssen die Ergebnisse von compare(a, z) und compare(b, z) für jedes z das gleiche Vorzeichen haben: Beide müssen negativ, beide gleich 0 oder beide positiv sein. Der Wert 0 bedeutet Gleichwertigkeit in dieser Reihenfolge, nicht unbedingt equals; in TreeSet und TreeMap wirkt sich das auf die Eindeutigkeit aus.
Comparator.comparing vergleicht extrahierte Schlüssel anhand ihrer natürlichen Reihenfolge oder eines übergebenen Comparators. Comparator.naturalOrder verwendet Comparable und lehnt null ab. Comparator.comparingInt verwendet einen int-Schlüssel, ohne ihn zu Integer zu verpacken.
Comparator.thenComparing ergänzt ein Kriterium, das nur bei Gleichstand verwendet wird; es akzeptiert einen Comparator oder einen Schlüssel-Extractor, optional mit einem Schlüssel-Comparator. Comparator.thenComparingInt ergänzt einen int-Schlüssel. Comparator.reversed kehrt die gesamte bis dahin aufgebaute Reihenfolge um, daher ist die Position des Aufrufs wichtig.
Comparator.nullsFirst und Comparator.nullsLast ordnen null jeweils vor oder nach den Nicht-null-Werten ein. Das Umhüllen des Schlüssel-Comparators schützt den Schlüssel; das Umhüllen der gesamten Reihenfolge schützt das Element. Wird ein umhüllter Comparator umgekehrt, ändert sich auch die Position von null.
Beispiele
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());
}
}
}Ergebnis
Bob:20:3 null:10:4 Ada:10:1 Ada:10:2 null
Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.
Quellen
- java.util (Java SE 21 & JDK 21)
- Comparator (Java SE 21 & JDK 21)
- Uses of Interface java.util.Comparator (Java SE 21 & JDK 21)
- Comparable (Java SE 21 & JDK 21)
- Official reference — docs.oracle.com: util / Comparator.html
- Official reference — docs.oracle.com: util / Comparator.html
- Official reference — docs.oracle.com: util / Comparator.html