0Pricing
Java Academy · Lektion

Arrays und Collections in der Praxis sortieren

Wenden Sie das Sortieren anhand realistischer Beispiele auf Produktlisten, Ranglisten und Veranstaltungspläne an.

Arrays und Collections in der Praxis sortieren ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Sortieren in der Praxis

Diese Lektion wendet Sortiertechniken auf realistische Szenarien an: Produktkataloge, Ranglisten, Ereignisplanung und die Sortierung von Suchergebnissen.

Arrays.sort für primitive Arrays

Arrays.sort() verwendet für Arrays primitiver Datentypen Quicksort mit zwei Pivot-Elementen – im Durchschnitt äußerst schnell mit O(n log n).

int[] scores = {45, 90, 78, 62, 88, 33};
Arrays.sort(scores);
System.out.println(Arrays.toString(scores)); // [33, 45, 62, 78, 88, 90]

// Sort a range only
int[] data = {9, 3, 7, 1, 5};
Arrays.sort(data, 1, 4); // sort indices 1-3 only
System.out.println(Arrays.toString(data)); // [9, 1, 3, 7, 5]

Arrays.sort für Objektarrays

Für Objektarrays verwendet Arrays.sort() TimSort (stabil). Sie können einen Comparator für eine benutzerdefinierte Reihenfolge angeben.

String[] names = {"Charlie", "Alice", "Bob", "Diana"};
Arrays.sort(names);
System.out.println(Arrays.toString(names)); // [Alice, Bob, Charlie, Diana]

// Custom order: by length, then alphabetically
Arrays.sort(names, Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()));
System.out.println(Arrays.toString(names)); // [Bob, Alice, Diana, Charlie]

Collections.sort und List.sort

Beide sortieren eine List direkt. List.sort() ist die moderne, bevorzugte Variante.

List<Integer> nums = new ArrayList<>(List.of(5, 2, 8, 1, 9, 3));

// Old way
Collections.sort(nums);
System.out.println(nums); // [1, 2, 3, 5, 8, 9]

// Modern way (same result)
nums.sort(Comparator.naturalOrder());
nums.sort(null); // null means natural order

// Descending
nums.sort(Comparator.reverseOrder());
System.out.println(nums); // [9, 8, 5, 3, 2, 1]

Stream.sorted() für einen funktionalen Stil

Verwenden Sie stream().sorted() beim Aufbau einer Pipeline – dadurch entsteht ein neuer sortierter Stream, ohne die Quelle zu verändern.

List<String> cities = List.of("Tokyo", "London", "New York", "Paris", "Sydney");

// Sorted stream — source list unchanged
List<String> sorted = cities.stream()
    .sorted(Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()))
    .collect(Collectors.toList());

System.out.println(sorted);
// [Paris, Tokyo, London, Sydney, New York]

Eine Map nach Werten sortieren

Eine klassische Frage in Bewerbungsgesprächen: Sortieren Sie eine Map mithilfe von Stream und Comparator nach ihren Werten.

import java.util.*;
import java.util.stream.*;

Map<String, Integer> scores = Map.of(
    "Alice", 95, "Bob", 87, "Charlie", 92, "Diana", 87
);

Map<String, Integer> sorted = scores.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue(Comparator.reverseOrder())
        .thenComparing(Map.Entry.comparingByKey()))
    .collect(Collectors.toLinkedHashMap(
        Map.Entry::getKey, Map.Entry::getValue,
        (v1, v2) -> v1, LinkedHashMap::new));

sorted.forEach((k, v) -> System.out.println(k + ": " + v));
// Alice: 95 / Charlie: 92 / Bob: 87 / Diana: 87

Sortieren mit Collator für sprachabhängige Reihenfolgen

Für eine sprachabhängige Sortierung von Zeichenketten verwenden Sie java.text.Collator statt String.compareTo – damit werden Akzente, Groß- und Kleinschreibung sowie sprachspezifische Sortierreihenfolgen berücksichtigt.

import java.text.*;
import java.util.*;

List<String> names = new ArrayList<>(List.of("éclair", "apple", "Über", "banana"));

Collator collator = Collator.getInstance(Locale.GERMAN);
names.sort(collator);
System.out.println(names); // locale-aware sort

Objekte nach mehreren Kriterien sortieren

Sortierung von E-Commerce-Produkten: zuerst verfügbare Produkte, dann nach Angebotspreis, anschließend nach Bewertung und zuletzt nach Name.

record Product(String name, double price, double salePrice, double rating, boolean inStock) {}

Comparator<Product> bestFirst = Comparator
    .comparing(Product::inStock).reversed()           // in-stock first
    .thenComparingDouble(Product::salePrice)          // cheapest sale price
    .thenComparingDouble(Product::rating).reversed()  // highest rated
    .thenComparing(Product::name);                    // alphabetical tiebreak

Ereignisse nach Datum und Uhrzeit sortieren

Sortieren Sie einen Zeitplan mit Ereignissen chronologisch mithilfe von java.time-Typen, die Comparable implementieren.

import java.time.*;
import java.util.*;

record Event(String title, LocalDate date, LocalTime time) {}

List<Event> schedule = new ArrayList<>(List.of(
    new Event("Workshop",  LocalDate.of(2024,7,15), LocalTime.of(9, 0)),
    new Event("Keynote",   LocalDate.of(2024,7,14), LocalTime.of(10, 30)),
    new Event("Lunch Talk",LocalDate.of(2024,7,15), LocalTime.of(12, 0)),
    new Event("Hackathon", LocalDate.of(2024,7,14), LocalTime.of(9, 0))
));

schedule.sort(Comparator.comparing(Event::date).thenComparing(Event::time));
schedule.forEach(e -> System.out.println(e.date() + " " + e.time() + " " + e.title()));

Top-N-Elemente durch Sortieren

Die effizienteste Ermittlung der Top-N-Elemente: absteigend sortieren und die ersten N Elemente übernehmen oder für große Datenmengen eine PriorityQueue verwenden.

List<Integer> values = List.of(42, 17, 88, 5, 73, 56, 91, 33);

// Simple approach: sort descending, take first 3
List<Integer> top3 = values.stream()
    .sorted(Comparator.reverseOrder())
    .limit(3)
    .collect(Collectors.toList());
System.out.println(top3); // [91, 88, 73]

// For very large datasets: PriorityQueue min-heap approach is O(n log k)
import java.util.PriorityQueue;
PriorityQueue<Integer> heap = new PriorityQueue<>(3);
for (int v : values) {
    heap.offer(v);
    if (heap.size() > 3) heap.poll();
}
System.out.println(new TreeSet<>(heap).descendingSet()); // [73, 88, 91]

Duplikate durch Sortieren erkennen

Nach dem Sortieren stehen Duplikate nebeneinander – dadurch ist eine Erkennung in O(n) möglich.

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5};
Arrays.sort(arr); // sort first

// Remove duplicates in O(n) after sorting
int[] unique = Arrays.stream(arr).distinct().toArray();
System.out.println(Arrays.toString(unique)); // [1, 2, 3, 4, 5, 6, 9]

Leistung: Die Sortiermethode auswählen

Wählen Sie den passenden Sortieransatz:

  • Primitive Arrays: Arrays.sort() – am schnellsten, Quicksort direkt im Array
  • Objektarrays/Listen mit Comparable: Collections.sort() oder List.sort(null)
  • Mehrere Sortierreihenfolgen: Comparator-Ketten mit thenComparing
  • Top-N aus einem großen Stream: PriorityQueue oder Stream.sorted().limit(N)

Kurztest

Welchen Sortieralgorithmus verwendet Java für Objektarrays in Arrays.sort()?

Zusammenfassung: Arrays und Collections in der Praxis sortieren

Die wichtigsten Erkenntnisse:

  • Arrays.sort() verwendet für primitive Datentypen Quicksort mit zwei Pivot-Elementen und für Objekte TimSort (stabil)
  • List.sort(comparator) und Collections.sort() verwenden beide stabiles TimSort
  • stream().sorted() erzeugt einen neuen sortierten Stream, ohne die Quelle zu verändern
  • Map nach Wert sortieren: entrySet().stream().sorted(Map.Entry.comparingByValue())
  • Verwenden Sie Collator für eine sprachabhängige Sortierung von Zeichenketten
  • Für die Top-N aus großen Datenmengen ist eine PriorityQueue mit der Kapazität k effizienter als eine vollständige Sortierung

Häufig gestellte Fragen

Ist die Lektion „Arrays und Collections in der Praxis sortieren“ kostenlos?

Ja — der vollständige Text von „Arrays und Collections in der Praxis sortieren“ 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 „Arrays und Collections in der Praxis sortieren“?

Wenden Sie das Sortieren anhand realistischer Beispiele auf Produktlisten, Ranglisten und Veranstaltungspläne an. 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 4 von 4.

Wie lange dauert die Lektion „Arrays und Collections in der Praxis sortieren“?

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