Wie man eine Liste in Java sortiert: list.sort, Comparator, mehrere Bedingungen und Nullbehandlung

1. Was Sie in diesem Artikel lernen werden (Der kürzeste Weg, eine Java‑Liste zu sortieren)

Bei der Arbeit mit Java kommt es extrem häufig vor, dass man Situationen begegnet, in denen man eine List sortieren muss.
Gleichzeitig werden viele Entwickler – besonders Anfänger – von Fragen wie diesen verwirrt:

• Welche Methode sollte ich zum Sortieren einer List verwenden?
• Was ist der Unterschied zwischen list.sort() und Collections.sort() ?
• Wie sortiere ich eine List von Objekten anstelle einfacher Werte?

Dieser Artikel ist darauf ausgelegt, diese Fragen klar und praktisch zu beantworten, beginnend mit der Schlussfolgerung und dann nach und nach die Details und Anwendungsfälle aus der Praxis zu erklären.

1.1 Die Schlussfolgerung: Das ist das einzige Muster, das Sie sich merken müssen

Wenn Sie einfach die kürzeste und standardmäßigste Methode zum Sortieren einer List in Java wollen, ist das hier die Lösung:

list.sort(Comparator.naturalOrder());

Dies sortiert die List in aufsteigender Reihenfolge (kleinste bis größte, A bis Z, älteste bis neueste).

Wenn Sie absteigende Reihenfolge wünschen, verwenden Sie stattdessen das Folgende:

list.sort(Comparator.reverseOrder());

Mit nur diesen beiden Zeilen können Sie bereits Listen von:

• Integer
• String
• LocalDate
• und den meisten anderen gängigen Typen

sortieren. Für viele alltägliche Fälle ist das alles, was Sie benötigen.

1.2 Sortieren einer List von Objekten: Den Sortierschlüssel angeben

In realen Anwendungen enthalten Listen meist Objekte, nicht einfache Werte.

Zum Beispiel:

class Person {
    private String name;
    private int age;

    // getters omitted
}

Um eine List<Person> nach Alter zu sortieren, schreiben Sie:

list.sort(Comparator.comparing(Person::getAge));

Diese eine Zeile bedeutet:

• Extrahiere age aus jeder Person
• Vergleiche diese Werte
• Sortiere die List in aufsteigender Reihenfolge

Sie müssen die Vergleichslogik nicht manuell implementieren.
Merken Sie sich einfach dieses Muster:

Comparator.comparing(whatToCompare)

1.3 Was dieser Artikel abdeckt

Dieser Artikel erklärt das Sortieren von Java‑Listen von den Grundlagen bis zur praktischen Anwendung, einschließlich:

• Der Unterschied zwischen list.sort() und Collections.sort()
• Wie Comparator in einfachen Begriffen funktioniert
• Sortieren mit mehreren Bedingungen (z. B.: Alter → Name)
• Mischen von aufsteigender und absteigender Reihenfolge
• Wie man null‑Werte sicher behandelt
• Wann man stream().sorted() anstelle von list.sort() verwendet

Ziel ist nicht das Auswendiglernen, sondern das Verstehen, warum jeder Ansatz existiert.

1.4 Für wen dieser Artikel gedacht ist

Dieser Artikel ist für Entwickler geschrieben, die:

• Grundlegende Java‑Syntax verstehen (Klassen, Methoden, Listen)
• ArrayList oder List bereits verwendet haben
• Jedes Mal, wenn sie sortieren müssen, noch nach Code suchen müssen

Er richtet sich nicht an absolute Anfänger, die noch nie Java‑Code geschrieben haben,
aber er ist einsteigerfreundlich für Entwickler, die praktische Java‑Programmierung lernen.

2. Drei gängige Methoden, eine List in Java zu sortieren (Welche sollten Sie verwenden?)

In Java gibt es nicht nur einen Weg, eine List zu sortieren.
In der Praxis verwenden Entwickler hauptsächlich drei verschiedene Ansätze, jeder mit leicht unterschiedlichem Verhalten und Ziel.

Bevor man tiefer in Comparator einsteigt, ist es wichtig zu verstehen, wann und warum jede Option existiert.

2.1 list.sort(Comparator) — Der moderne und empfohlene Ansatz

Seit Java 8 ist dies die Standard‑ und am häufigsten empfohlene Methode zum Sortieren einer List.

list.sort(Comparator.naturalOrder());

Wesentliche Merkmale

• Direkt im List‑Interface definiert
• Klar und lesbar
• Sortiert die ursprüngliche List vor Ort (destruktiv)

Das Sortieren von Objekten funktioniert auf dieselbe Weise:

list.sort(Comparator.comparing(Person::getAge));

Wann man es einsetzen sollte

• Wenn Sie damit einverstanden sind, die ursprüngliche List zu verändern
• Wenn Sie die klarste und einfachste Lösung wollen

👉 Falls Sie unsicher sind, ist list.sort() in der Regel die richtige Wahl.

2.2 Collections.sort(list) — Älterer Stil, den Sie trotzdem kennen sollten

Sie könnten solchen Code in älteren Tutorials oder Legacy‑Projekten sehen:

Collections.sort(list);

Oder mit einem Comparator:

Collections.sort(list, Comparator.reverseOrder());

Wesentliche Merkmale

• Existiert seit Java 1.2
• Verhält sich intern fast genauso wie list.sort
• Modifiziert ebenfalls die ursprüngliche Liste

Warum es heute weniger verbreitet ist

• Java 8 führte list.sort ein, das sich natürlicher anfühlt
• Eine Liste über Collections zu sortieren ist weniger intuitiv

Für neuen Code ist list.sort bevorzugt.
Dennoch ist das Verständnis von Collections.sort wichtig, wenn man ältere Codebasen liest.

2.3 stream().sorted() — Nicht-destruktives Sortieren

Die dritte Option nutzt die Stream‑API.

List<Integer> sorted =
    list.stream()
        .sorted()
        .toList();

Mit einem Comparator:

List<Person> sorted =
    list.stream()
        .sorted(Comparator.comparing(Person::getAge))
        .toList();

Wesentliche Merkmale

• Modifiziert die ursprüngliche Liste NICHT
• Gibt eine neue sortierte Liste zurück
• Einfach zu kombinieren mit filter, map und anderen Stream‑Operationen

Wann man es verwendet

• Wenn die ursprüngliche Liste unverändert bleiben muss
• Wenn das Sortieren Teil einer Datenverarbeitungspipeline ist

Für einfaches Sortieren ist jedoch list.sort in der Regel klarer und effizienter.

2.4 Wie man wählt (Schnell‑Entscheidungs‑Leitfaden)

An dieser Stelle gilt nur eine Regel:

Verwende list.sort(), es sei denn, du hast einen klaren Grund, es nicht zu tun.

3. Grundlegendes Sortieren: Aufsteigende und absteigende Reihenfolge

Jetzt, wo du welche Sortiermethode du verwenden solltest kennst, konzentrieren wir uns auf die häufigste Anforderung:
Sortieren in aufsteigender oder absteigender Reihenfolge.

Dieser Abschnitt behandelt Listen von Basistypen wie Zahlen, Zeichenketten und Datumsangaben – die Grundlage für alles, was folgt.

3.1 Sortieren in aufsteigender Reihenfolge (natürliche Ordnung)

Viele Java‑Typen haben eine natürliche Ordnung, zum Beispiel:

• Zahlen → von klein nach groß
• Zeichenketten → alphabetische Reihenfolge (A bis Z)
• Datumsangaben → älter zu neuer

Um eine Liste in aufsteigender Reihenfolge zu sortieren, verwende:

list.sort(Comparator.naturalOrder());

Beispiel: Zahlen sortieren

List<Integer> numbers = Arrays.asList(5, 1, 3, 2);
numbers.sort(Comparator.naturalOrder());

Ergebnis:

[1, 2, 3, 5]

Beispiel: Zeichenketten sortieren

List<String> names = Arrays.asList("Tom", "Alice", "Bob");
names.sort(Comparator.naturalOrder());

Ergebnis:

[Alice, Bob, Tom]

👉 Wenn du nur die aufsteigende Reihenfolge möchtest, ist dies der einfachste und sicherste Ansatz.

3.2 Sortieren in absteigender Reihenfolge

Um die natürliche Reihenfolge umzukehren, verwende Comparator.reverseOrder().

list.sort(Comparator.reverseOrder());

Beispiel: Zahlen in absteigender Reihenfolge

List<Integer> numbers = Arrays.asList(5, 1, 3, 2);
numbers.sort(Comparator.reverseOrder());

Ergebnis:

[5, 3, 2, 1]

Beispiel: Zeichenketten in absteigender Reihenfolge

List<String> names = Arrays.asList("Tom", "Alice", "Bob");
names.sort(Comparator.reverseOrder());

Ergebnis:

[Tom, Bob, Alice]

3.3 Wenn der Comparator weggelassen werden kann

In manchen Fällen sieht man Sortiercode ohne expliziten Comparator.

Collections.sort(list);

Oder sogar:

list.sort(null);

Diese funktionieren nur wenn:

• Die Elemente implementieren Comparable
• Du die natürliche (aufsteigende) Reihenfolge möchtest

Obwohl gültig, sind diese Stile weniger explizit. In realen Codebasen wird diese Variante meist aus Gründen der Klarheit bevorzugt:

list.sort(Comparator.naturalOrder());

3.4 Ein häufiges Missverständnis: Wer entscheidet die Reihenfolge?

Eine häufige Verwirrungsquelle für Anfänger ist die Annahme, dass:

sort() entscheidet über die auf- oder absteigende Reihenfolge

In Wirklichkeit:

• sort() führt die Sortierung durch
• Comparator definiert wie Elemente verglichen werden

Sobald du diese Trennung der Verantwortlichkeiten verstehst, wird alles andere – Objektsortierung, mehrere Bedingungen und der Umgang mit null – viel einfacher.

4. Sortieren einer Liste von Objekten: Verständnis von Comparator

In realen Java‑Anwendungen sortieren Sie selten einfache Werte wie Integer oder String.
Meistens sortieren Sie Listen von benutzerdefinierten Objekten.

Hier kommt Comparator als Kernkonzept ins Spiel.

4.1 Was ist ein Comparator?

Ein Comparator definiert wie zwei Elemente verglichen werden sollen.

Konzeptionell beantwortet er diese Frage:

“Gegeben zwei Objekte, welches sollte zuerst kommen?”

Intern gibt ein Comparator zurück:

• Eine negative Zahl → das erste Element kommt zuerst
• Null → die Reihenfolge ist egal
• Eine positive Zahl → das zweite Element kommt zuerst

Glücklicherweise müssen Sie in modernem Java diese Logik fast nie manuell implementieren.

4.2 Sortieren nach einem Feld mit Comparator.comparing

Betrachten Sie die folgende Klasse:

class Person {
    private String name;
    private int age;

    // getters omitted
}

Um eine List<Person> nach dem Alter zu sortieren, verwenden Sie:

list.sort(Comparator.comparing(Person::getAge));

Das liest sich natürlich:

• Nehmen Sie jede Person
• Extrahieren Sie das age
• Vergleichen Sie diese Werte
• Sortieren Sie die Liste aufsteigend

Diese eine Zeile ersetzt viele Zeilen älteren Vergleichscode.

4.3 Sortieren nach Strings, Daten und anderen Typen

Das gleiche Muster funktioniert für fast jeden Feldtyp.

Sortieren nach Name

list.sort(Comparator.comparing(Person::getName));

Sortieren nach Datum

list.sort(Comparator.comparing(Person::getBirthDate));

Solange der extrahierte Wert eine natürliche Ordnung hat,
funktioniert Comparator.comparing ohne zusätzliche Konfiguration.

4.4 Verwendung von primitivespezifischen Comparators

Für numerische Felder stellt Java optimierte Methoden bereit:

• comparingInt
• comparingLong
• comparingDouble

Beispiel:

list.sort(Comparator.comparingInt(Person::getAge));

Diese Methoden:

• Vermeiden unnötiges Objekt‑Boxing
• Machen Ihre Absicht klarer
• Sind bei großen Listen etwas effizienter

Obwohl der Unterschied klein ist, gelten sie als Best Practice für numerische Felder.

4.5 Warum das wichtig ist

Sobald Sie Comparator.comparing verstehen, öffnen Sie:

• Sortieren mit mehreren Bedingungen
• Gemischte auf‑ und absteigende Reihenfolge
• Sichere Handhabung von null‑Werten

Mit anderen Worten, das ist die Grundlage für praktisches Listensortieren in Java.

5. Sortieren mit mehreren Bedingungen (Das häufigste Muster in der Praxis)

In realen Anwendungen reicht das Sortieren nach einem einzigen Feld oft nicht aus.
Sie benötigen normalerweise sekundäre und tertiäre Bedingungen, um eine stabile und sinnvolle Reihenfolge zu erzeugen.

Beispiele umfassen:

• Sortieren nach Alter, dann nach Name
• Sortieren nach Priorität, dann nach Zeitstempel
• Sortieren nach Punktzahl (absteigend), dann nach ID (aufsteigend)

Die Comparator‑API von Java ist dafür speziell konzipiert.

5.1 Die Grundlagen von thenComparing

Das Sortieren mit mehreren Bedingungen folgt einer einfachen Regel:

Wenn zwei Elemente nach der ersten Bedingung gleich sind, verwenden Sie die nächste Bedingung.

Hier ist das Grundmuster:

list.sort(
    Comparator.comparingInt(Person::getAge)
              .thenComparing(Person::getName)
);

Das bedeutet:

1. Sortieren nach age (aufsteigend)
2. Wenn das Alter gleich ist, sortieren nach name (aufsteigend)

Dies erzeugt eine konsistente und vorhersehbare Reihenfolge.

5.2 Mischen von aufsteigender und absteigender Reihenfolge

Sehr oft möchten Sie ein Feld absteigend und ein anderes aufsteigend sortieren.

Beispiel: Punktzahl (absteigend), Name (aufsteigend)

list.sort(
    Comparator.comparingInt(Person::getScore).reversed()
              .thenComparing(Person::getName)
);

Wichtiger Hinweis:

• reversed() gilt nur für den Comparator, der unmittelbar davor steht

Damit ist es sicher, verschiedene Sortierrichtungen zu kombinieren.

5.3 Übergabe eines Comparators an thenComparing

Für bessere Lesbarkeit können Sie die Sortierrichtung explizit innerhalb von thenComparing festlegen.

Beispiel: Alter (aufsteigend), Registrierungsdatum (absteigend)

list.sort(
    Comparator.comparingInt(Person::getAge)
              .thenComparing(
                  Comparator.comparing(Person::getRegisterDate).reversed()
              )
);

Dieser Stil macht sehr deutlich, welche Felder aufsteigend oder absteigend sortiert werden,
was bei Code‑Reviews und der langfristigen Wartung hilfreich ist.

5.4 Ein realistisches Business‑Beispiel

list.sort(
    Comparator.comparingInt(Order::getPriority)
              .thenComparing(Order::getDeadline)
              .thenComparing(Order::getOrderId)
);

Sortierlogik:

1. Höhere Priorität zuerst
2. Frühere Frist zuerst
3. Niedrigere Bestell‑ID zuerst

Dies stellt eine stabile und geschäftsfreundliche Reihenfolge sicher.

5.5 Mehrfachbedingte Sortierung lesbar halten

Wenn die Sortierlogik wächst, wird die Lesbarkeit wichtiger als Kürze.

Best Practices:

• Zeilen für jede Bedingung umbrechen
• Tief verschachtelte Lambdas vermeiden
• Kommentare hinzufügen, wenn Geschäftsregeln nicht offensichtlich sind

Klare Sortierlogik spart Zeit für alle, die den Code später lesen.

6. null‑Werte sicher behandeln (eine sehr häufige Fehlerquelle)

Beim Sortieren von realen Daten sind null‑Werte fast unvermeidlich.
Felder können optional sein, Altdaten können unvollständig sein oder Werte können einfach fehlen.

Wenn Sie null nicht explizit behandeln, kann das Sortieren zur Laufzeit leicht fehlschlagen.

6.1 Warum null beim Sortieren Probleme verursacht

Betrachten Sie diesen Code:

list.sort(Comparator.comparing(Person::getName));

Wenn getName() für ein Element null zurückgibt, wirft Java während des Vergleichs eine
NullPointerException.

Das passiert, weil:

• Ein Comparator geht davon aus, dass Werte vergleichbar sind
• null hat keine natürliche Reihenfolge, sofern Sie nicht eine definieren

Daher muss die null‑Behandlung explizit sein.

6.2 Verwendung von nullsFirst und nullsLast

Java bietet Hilfsmethoden, um festzulegen, wie null‑Werte sortiert werden sollen.

null‑Werte zuerst platzieren

list.sort(
    Comparator.comparing(
        Person::getName,
        Comparator.nullsFirst(Comparator.naturalOrder())
    )
);

null‑Werte zuletzt platzieren

list.sort(
    Comparator.comparing(
        Person::getName,
        Comparator.nullsLast(Comparator.naturalOrder())
    )
);

Diese Ansätze:

• Verhindern von NullPointerException
• Die Sortierregel explizit und lesbar machen

6.3 Wenn die Liste selbst null‑Elemente enthält

Manchmal können die Elemente der Liste selbst null sein.

List<Person> list = Arrays.asList(
    new Person("Alice", 20),
    null,
    new Person("Bob", 25)
);

Um dies sicher zu handhaben:

list.sort(
    Comparator.nullsLast(
        Comparator.comparing(Person::getName)
    )
);

Dies stellt sicher:

• null‑Elemente werden ans Ende verschoben
• Nicht‑null‑Elemente werden normal sortiert

6.4 Vorsicht bei comparingInt und null

Primitiv‑spezifische Comparatoren wie comparingInt können null nicht verarbeiten.

Comparator.comparingInt(Person::getAge); // age must be int

Wenn das Feld ein Integer ist, das null sein kann, verwenden Sie:

Comparator.comparing(
    Person::getAge,
    Comparator.nullsLast(Integer::compare)
);

Damit vermeiden Sie unerwartete Laufzeitfehler.

6.5 null‑Behandlung als Teil der Spezifikation behandeln

Entscheiden, ob null‑Werte erscheinen sollen:

• Am Anfang
• Am Ende
• Oder vollständig herausgefiltert werden

ist eine geschäftliche Entscheidung, nicht nur eine technische.

Durch die Verwendung von nullsFirst oder nullsLast dokumentieren Sie diese Entscheidung direkt im Code—
was Ihre Sortierlogik sicherer und leichter verständlich macht.

7. Häufige Fallstricke und Fehler (wie subtile Bugs vermeiden)

Das Sortieren einer List in Java wirkt einfach, aber es gibt mehrere leicht zu übersehende Fallstricke, die zu Bugs, unerwartetem Verhalten oder Leistungsproblemen führen können.

Wenn Sie diese im Voraus verstehen, sparen Sie Zeit beim Debuggen und bei Code‑Reviews.

7.1 Vergessen, dass Sortieren destruktiv ist

Both list.sort() and Collections.sort() ändern die ursprüngliche Liste.

List<Integer> original = new ArrayList<>(List.of(3, 1, 2));
List<Integer> alias = original;

original.sort(Comparator.naturalOrder());

In diesem Fall:

• original ist sortiert
• alias ist ebenfalls sortiert (weil sie auf dieselbe Liste verweisen)

Wie man das vermeidet

Wenn Sie die ursprüngliche Reihenfolge beibehalten müssen:

List<Integer> sorted = new ArrayList<>(original);
sorted.sort(Comparator.naturalOrder());

Oder verwenden Sie Streams:

List<Integer> sorted =
    original.stream()
            .sorted()
            .toList();

Fragen Sie sich immer:
„Ist es in Ordnung, die ursprüngliche Liste zu ändern?“

7.2 Konsistenz von Comparatoren und stabile Sortierung

Ein Comparator sollte konsistente und vorhersehbare Ergebnisse liefern.

Beispiel:

Comparator.comparing(Person::getAge);

Wenn mehrere Personen das gleiche Alter haben, ist ihre relative Reihenfolge undefiniert.

Das kann akzeptabel sein – aber oft ist es das nicht.

Beste Praxis

Fügen Sie eine sekundäre Bedingung hinzu, um die Reihenfolge zu stabilisieren:

Comparator.comparingInt(Person::getAge)
          .thenComparing(Person::getId);

Das stellt sicher, dass das Sortierergebnis deterministisch ist.

7.3 Groß‑/Kleinschreibung beim Sortieren von Strings

Die natürliche Reihenfolge von String ist groß‑/kleinschreibungssensitiv.

List<String> list = List.of("apple", "Banana", "orange");
list.sort(Comparator.naturalOrder());

Das kann Ergebnisse erzeugen, die unintuitiv wirken.

Sortieren ohne Groß‑/Kleinschreibung

list.sort(String.CASE_INSENSITIVE_ORDER);

Vor der Auswahl sollten Sie überlegen:

• Ist das für die Anzeige gedacht?
• Oder für die interne Logik?

Die Antwort bestimmt den richtigen Ansatz.

7.4 Aufwändige Arbeit innerhalb eines Comparators ausführen

Ein Comparator kann beim Sortieren viele Male aufgerufen werden.

Vermeiden Sie:

• Datenbankzugriffe
• Netzwerkaufrufe
• Aufwändige Berechnungen

  // Bad idea (conceptual example)
  Comparator.comparing(p -> expensiveOperation(p));
  

Besserer Ansatz

• Werte vorab berechnen
• In Feldern speichern
• Einfache, günstige Werte vergleichen

Effiziente Comparatoren machen bei großen Listen einen großen Unterschied.

7.5 Lesbarkeit vor Cleverness priorisieren

Sortierlogik wird oft öfter gelesen als geschrieben.

Statt:

• Ein langer verketteter Ausdruck
• Tief verschachtelte Lambdas

Bevorzugen Sie:

• Zeilenumbrüche
• Klare Struktur
• Optionale Kommentare für Geschäftsregeln

Lesbarer Sortiercode reduziert Fehler und erleichtert die Wartung.

8. Leistungsüberlegungen und Auswahl des richtigen Ansatzes

Jetzt wissen Sie wie man Listen in Java sortiert.
Dieser Abschnitt konzentriert sich darauf, welchen Ansatz man aus Leistungs‑ und Designperspektive wählen sollte.

In den meisten Anwendungen ist Sortieren kein Engpass – aber schlechte Entscheidungen können dennoch unnötigen Overhead verursachen.

8.1 list.sort() vs stream().sorted()

Dies ist der häufigste Entscheidungspunkt.

list.sort()

list.sort(Comparator.comparingInt(Person::getAge));

Vorteile

• Keine zusätzliche Listenzuweisung
• Klarer Zweck: „diese Liste sortieren“
• Etwas effizienter

Nachteile

• Ändert die ursprüngliche Liste

stream().sorted()

List<Person> sorted =
    list.stream()
        .sorted(Comparator.comparingInt(Person::getAge))
        .toList();

Vorteile

• Ursprüngliche Liste bleibt unverändert
• Passt natürlich in Stream‑Pipelines

Nachteile

• Erstellt eine neue Liste
• Etwas mehr Overhead

Praktische Regel

• Einfaches Sortieren → list.sort()
• Transformationspipelines oder Unveränderlichkeit → stream().sorted()

8.2 Große Listen effizient sortieren

Sortieralgorithmen rufen den Comparator viele Male auf.
Bei großen Listen ist das wichtig.

Wichtige Richtlinien

• Comparatoren leichtgewichtig halten
• Methodenketten vermeiden, die aufwändige Arbeit leisten
• Primitive Comparatoren bevorzugen (comparingInt usw.)

Beispiel: Aufwändige Schlüssel vorab berechnen

Statt:

Comparator.comparing(p -> calculateScore(p));

Do:

// Precompute once
p.setScore(calculateScore(p));

Dann sortieren Sie nach dem Feld:

Comparator.comparingInt(Person::getScore);

Dies reduziert den wiederholten Aufwand beim Sortieren drastisch.

8.3 Ist Collections.sort() jemals die richtige Wahl?

Für neuen Code fast nie.

Es taucht jedoch noch auf in:

• Alte Projekte
• Ältere Tutorials
• Java‑7- und frühere Codebasen

Sie müssen es nicht verwenden – aber Sie sollten es erkennen.

8.4 Empfohlene Entscheidungsliste

Vor dem Sortieren fragen Sie:

1. Kann ich die ursprüngliche Liste ändern?
2. Benötige ich mehrere Sortierbedingungen?
3. Können Felder null sein?
4. Ist die Leistung bei großem Umfang wichtig?

Die Beantwortung dieser Fragen führt natürlich zur richtigen Lösung.

9. Zusammenfassung: Java‑Listen‑Sortier‑Spickzettel

Fassen wir alles in einem Kurzreferenz‑Leitfaden zusammen, auf den Sie sich verlassen können.

9.1 Schnellmuster, die Sie am häufigsten verwenden

Aufsteigende Reihenfolge

list.sort(Comparator.naturalOrder());

Absteigende Reihenfolge

list.sort(Comparator.reverseOrder());

9.2 Objekte nach einem Feld sortieren

list.sort(Comparator.comparing(Person::getName));

Für Zahlen:

list.sort(Comparator.comparingInt(Person::getAge));

9.3 Mehrere Bedingungen

list.sort(
    Comparator.comparingInt(Person::getAge)
              .thenComparing(Person::getName)
);

Gemischte Reihenfolge:

list.sort(
    Comparator.comparingInt(Person::getScore).reversed()
              .thenComparing(Person::getName)
);

9.4 Sicherer Umgang mit null

list.sort(
    Comparator.comparing(
        Person::getName,
        Comparator.nullsLast(Comparator.naturalOrder())
    )
);

Liste kann null‑Elemente enthalten:

list.sort(
    Comparator.nullsLast(
        Comparator.comparing(Person::getName)
    )
);

9.5 Nicht‑destruktives Sortieren

List<Person> sorted =
    list.stream()
        .sorted(Comparator.comparingInt(Person::getAge))
        .toList();

9.6 Fazit

Das Sortieren von Java‑Listen wird einfach, sobald Sie sich erinnern:

• Comparator definiert die Reihenfolge
• sort() führt die Operation aus
• Klarheit schlägt Cleverness
• Expliziter Umgang mit null verhindert Fehler

Wenn Sie diese Prinzipien verinnerlichen,
müssen Sie das Sortieren von Java‑Listen nie wieder „neu lernen“.