0Pricing
Java Academy · Lektion

Comparator und Sortieren mit Lambdas

Erstellen Sie Comparator-Instanzen mit Lambda-Ausdrücken und den Factory-Methoden von Comparator.comparing.

Comparator und Sortieren mit Lambdas ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Comparator und Sortierung mit Lambdas

Comparator<T> definiert eine externe Ordnung für Objekte. Anders als bei Comparable können Sie beliebig viele Comparatoren erstellen, ohne die Klasse zu ändern.

Comparatoren erstellen

Erstellen Sie einen Comparator mit einem Lambda-Ausdruck oder einer Methodenreferenz und übergeben Sie ihn an Sortiermethoden.

import java.util.*;

record Product(String name, double price, int stock) {}

List<Product> products = new ArrayList<>(List.of(
    new Product("Mouse",    29.99, 50),
    new Product("Laptop",  999.00, 5),
    new Product("USB Hub",  24.99, 100)
));

// Lambda comparator
products.sort((a, b) -> Double.compare(a.price(), b.price()));
System.out.println(products);
// [USB Hub, Mouse, Laptop] (by price ascending)

Die Comparator.comparing-Fabrikmethode

Comparator.comparing(keyExtractor) erstellt aus einer Funktion zur Schlüsselermittlung einen Comparator – übersichtlicher als unverpackte Lambda-Ausdrücke.

import java.util.Comparator;

Comparator<Product> byPrice = Comparator.comparingDouble(Product::price);
Comparator<Product> byName  = Comparator.comparing(Product::name);
Comparator<Product> byStock = Comparator.comparingInt(Product::stock);

products.sort(byPrice);
System.out.println(products); // sorted by price ascending

products.sort(byName);
System.out.println(products); // sorted alphabetically

reversed()

reversed() kehrt die Reihenfolge eines beliebigen Comparators um.

import java.util.Comparator;

Comparator<Product> mostExpensiveFirst =
    Comparator.comparingDouble(Product::price).reversed();

products.sort(mostExpensiveFirst);
System.out.println(products);
// [Laptop($999.0), Mouse($29.99), USB Hub($24.99)]

naturalOrder und reverseOrder

Comparator.naturalOrder() verwendet Comparable der Klasse. reverseOrder() kehrt diese Reihenfolge um.

List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob"));

names.sort(Comparator.naturalOrder());
System.out.println(names); // [Alice, Bob, Charlie]

names.sort(Comparator.reverseOrder());
System.out.println(names); // [Charlie, Bob, Alice]

// Sort integers descending
List<Integer> nums = new ArrayList<>(List.of(5, 2, 8, 1, 9));
nums.sort(Comparator.reverseOrder());
System.out.println(nums); // [9, 8, 5, 2, 1]

Null-sichere Comparatoren

Comparator.nullsFirst() und nullsLast() behandeln null-Elemente ohne NPE.

import java.util.*;

List<String> withNulls = new ArrayList<>(Arrays.asList("Charlie", null, "Alice", null, "Bob"));

withNulls.sort(Comparator.nullsLast(Comparator.naturalOrder()));
System.out.println(withNulls); // [Alice, Bob, Charlie, null, null]

withNulls.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
System.out.println(withNulls); // [null, null, Alice, Bob, Charlie]

Stream sorted() mit Comparator

Verwenden Sie die mittlere Stream-Operation sorted() mit einem Comparator für eine Sortierung im funktionalen Stil.

import java.util.stream.*;

record Employee(String name, String dept, double salary) {}

List<Employee> employees = List.of(
    new Employee("Alice",   "Engineering", 95000),
    new Employee("Bob",     "Marketing",   72000),
    new Employee("Charlie", "Engineering", 105000)
);

// Sort by salary descending in a stream pipeline
employees.stream()
    .sorted(Comparator.comparingDouble(Employee::salary).reversed())
    .forEach(e -> System.out.println(e.name() + ": $" + e.salary()));
// Charlie: $105000.0 / Alice: $95000.0 / Bob: $72000.0

Comparator als Lambda-Ausdruck oder Methodenreferenz

Methodenreferenzen machen Comparatoren noch kompakter, wenn der Schlüssel durch einen einfachen Getter ermittelt wird.

// Lambda
Comparator<String> c1 = (a, b) -> a.length() - b.length();

// Comparator.comparing with lambda
Comparator<String> c2 = Comparator.comparing(s -> s.length());

// Comparator.comparingInt with method reference (cleanest)
Comparator<String> c3 = Comparator.comparingInt(String::length);

List<String> words = new ArrayList<>(List.of("banana", "fig", "apple", "kiwi"));
words.sort(c3);
System.out.println(words); // [fig, kiwi, apple, banana]

Zustandsbehafteter Comparator

Obwohl Comparatoren normalerweise zustandslos sein sollten, können Sie über Konstruktorparameter Konfiguration übergeben.

class DistanceComparator implements Comparator<String> {
    private final String target;
    DistanceComparator(String target) { this.target = target; }

    @Override
    public int compare(String a, String b) {
        return Integer.compare(distance(a), distance(b));
    }

    private int distance(String s) { return Math.abs(s.length() - target.length()); }
}

List<String> words = new ArrayList<>(List.of("Java", "Go", "Python", "C", "Kotlin"));
words.sort(new DistanceComparator("Java"));
System.out.println(words); // closest length to "Java" first

Benutzerdefinierte Sortierung für einen Produktkatalog

Sortieren eines Produktkatalogs zuerst nach Verfügbarkeit, dann nach Preis und anschließend nach Name.

import java.util.*;

record Item(String name, double price, boolean inStock) {}

List<Item> catalog = List.of(
    new Item("Laptop",  999.0,  true),
    new Item("Case",     19.99, false),
    new Item("Mouse",    29.99, true),
    new Item("Monitor", 349.0,  true)
);

Comparator<Item> catalogSort =
    Comparator.comparing(Item::inStock).reversed()     // in-stock first
    .thenComparingDouble(Item::price)                  // then cheapest
    .thenComparing(Item::name);                        // then alphabetical

catalog.stream().sorted(catalogSort)
    .forEach(i -> System.out.printf("%s %-15s $%.2f%n",
        i.inStock() ? "[Y]" : "[N]", i.name(), i.price()));

Arrays.sort mit Comparator

Arrays.sort(array, comparator) sortiert Objekt-Arrays mit einem benutzerdefinierten Comparator.

String[] words = {"banana", "fig", "apple", "kiwi", "cherry"};

// Sort by length, then alphabetically for same length
Arrays.sort(words,
    Comparator.comparingInt(String::length)
              .thenComparing(Comparator.naturalOrder()));

System.out.println(Arrays.toString(words));
// [fig, kiwi, apple, banana, cherry]

Schnelltest

Was ergibt Comparator.comparingDouble(Product::price).reversed()?

Zusammenfassung: Comparator und Sortierung mit Lambdas

Die wichtigsten Erkenntnisse:

  • Comparator<T> definiert eine externe Ordnung – verwenden Sie beliebig viele Comparatoren
  • Comparator.comparing(keyExtractor) erstellt Comparatoren aus Gettern
  • reversed() kehrt jeden Comparator um; naturalOrder()/reverseOrder() sind für Comparable-Typen vorgesehen
  • nullsFirst() und nullsLast() behandeln null-Elemente sicher
  • Verwenden Sie sorted(comparator) in Stream-Pipelines für eine Sortierung im funktionalen Stil
  • Comparatoren können an sort(), Arrays.sort(), TreeSet und TreeMap übergeben werden

Häufig gestellte Fragen

Ist die Lektion „Comparator und Sortieren mit Lambdas“ kostenlos?

Ja — der vollständige Text von „Comparator und Sortieren mit Lambdas“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Comparator und Sortieren mit Lambdas“?

Erstellen Sie Comparator-Instanzen mit Lambda-Ausdrücken und den Factory-Methoden von Comparator.comparing. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Comparator und Sortieren mit Lambdas“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Die Comparable-Schnittstelle
  2. Comparator und Sortieren mit Lambdas
  3. Sortieren nach mehreren Schlüsseln mit thenComparing
  4. Arrays und Collections in der Praxis sortieren
← Zurück zu Java Academy