Suche und Sortierung von Elementen in Java-Collections

1. Suche von Elementen in Collections

Suche mit Standardmethoden

Wenn wir eine Liste haben, zum Beispiel von Namen:

List<String> names = List.of("Anna", "Boris", "Viktoria", "Anna", "Dmitri");

Java bietet mehrere bequeme Methoden für die Suche:

• contains(Object o) – prüft, ob ein Element in der Collection vorhanden ist.
• indexOf(Object o) – gibt den ersten Index des Vorkommens eines Elements zurück (oder -1, wenn nicht gefunden).
• lastIndexOf(Object o) – gibt den letzten Index des Vorkommens zurück (oder -1).

Beispiele:

System.out.println(names.contains("Anna"));      // true
System.out.println(names.indexOf("Anna"));       // 0
System.out.println(names.lastIndexOf("Anna"));   // 3
System.out.println(names.contains("Sergej"));    // false

Fakt: Für Collections vom Typ Set gibt es keine Methoden indexOf und lastIndexOf – ein Set hat überhaupt keine Indizes, nur eindeutige Werte.

Suche nach Bedingung

Manchmal muss man nicht einen konkreten Wert finden, sondern ein Element, das einer Bedingung entspricht. Zum Beispiel den ersten Namen mit mehr als 6 Zeichen finden. Eine normale for-Schleife eignet sich hervorragend: Sobald ein passendes Element gefunden wurde – verwenden Sie break.

List<String> names = List.of("Anna", "Boris", "Viktoria", "Anna", "Dmitri");

String found = null;
for (String name : names) {
    if (name.length() > 6) {
        found = name;
        break; // Erstes passendes Element gefunden – Schleife kann verlassen werden
    }
}
System.out.println(found); // Viktoria

Suche nach dem maximalen und minimalen Wert

Für Collections mit vergleichbaren Elementen (z. B. Zahlen) kann man Maximum und Minimum schnell mit der Klasse Collections finden.

List<Integer> numbers = List.of(10, 5, 20, 7, 20, 3);

int max = Collections.max(numbers); // 20
int min = Collections.min(numbers); // 3

System.out.println("Maximum: " + max);
System.out.println("Minimum: " + min);

Wichtig: Die Elemente müssen vergleichbar sein ( Comparable implementieren), andernfalls muss ein Comparator übergeben werden.

2. Sortierung von Collections

Standardsortierung einer Liste

Sortieren kann man nur veränderliche Listen (z. B. ArrayList, LinkedList). Collections vom Typ Set und Map unterstützen keine direkte Sortierung.

Standardmäßig erfolgt die Sortierung nach der „natürlichen Ordnung“: bei Zahlen – aufsteigend, bei Strings – alphabetisch.

List<Integer> numbers = new ArrayList<>(List.of(5, 1, 7, 3));
Collections.sort(numbers);
System.out.println(numbers); // [1, 3, 5, 7]

Dasselbe lässt sich über die Listenmethode sort erledigen:

List<Integer> numbers = new ArrayList<>(List.of(5, 1, 7, 3));
numbers.sort(null); // null bedeutet: die natürliche Ordnung verwenden
System.out.println(numbers); // [1, 3, 5, 7]

Sortierung mit Comparator

Wenn man eine eigene Regel benötigt – z. B. Strings nach Länge sortieren:

List<String> words = new ArrayList<>(List.of("Katze", "Elefant", "Fliege", "Nashorn"));

words.sort(Comparator.comparingInt(String::length));
System.out.println(words); // [Katze, Fliege, Elefant, Nashorn]

In umgekehrter Reihenfolge:

words.sort(Comparator.comparingInt(String::length).reversed());
System.out.println(words); // [Elefant, Nashorn, Fliege, Katze]

Alter Stil über Collections.sort:

Collections.sort(words, Comparator.comparingInt(String::length));

3. Besonderheiten der Sortierung verschiedener Collections

Sortieren verändert nur die Liste

Die Sortiermethoden (sort, Collections.sort) funktionieren nur mit Collections, die eine Ordnung der Elemente unterstützen (z. B. List). Für Set und Map sind solche Methoden nicht vorgesehen.

Versuch, ein Set zu sortieren:

Set<Integer> mySet = new HashSet<>(List.of(3, 1, 2));
Collections.sort(mySet); // Kompilierfehler: sort erwartet eine List!

Wenn man eine sortierte Liste aus Set erhalten möchte:

List<Integer> sortedFromSet = new ArrayList<>(mySet);
Collections.sort(sortedFromSet);
System.out.println(sortedFromSet); // [1, 2, 3]

Sortierung einer Map: nach Schlüsseln und nach Werten

Eine Map lässt sich nicht direkt sortieren, aber man kann:

• Eine Liste der „Schlüssel–Wert“-Paare erhalten
• Sie nach Bedarf sortieren
• Bei Bedarf eine neue Map zusammenstellen

Beispiel: Sortierung nach Werten

Map<String, Integer> scores = Map.of(
    "Anna", 15,
    "Boris", 20,
    "Vika", 12
);

List<Map.Entry<String, Integer>> entries = new ArrayList<>(scores.entrySet());
entries.sort(Map.Entry.comparingByValue());

for (Map.Entry<String, Integer> entry : entries) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
// Vika: 12
// Anna: 15
// Boris: 20

Sortierung von Objekten nach einem Feld

Angenommen, wir haben eine Benutzerklasse:

class User {
    String name;
    int age;
    User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

Und eine Liste von Benutzern:

List<User> users = new ArrayList<>(List.of(
    new User("Anna", 22),
    new User("Boris", 18),
    new User("Vika", 25)
));

Wir sortieren nach Alter:

users.sort(Comparator.comparingInt(u -> u.age));
System.out.println(users); // [Boris (18), Anna (22), Vika (25)]

In umgekehrter Reihenfolge:

users.sort(Comparator.comparingInt((User u) -> u.age).reversed());
System.out.println(users); // [Vika (25), Anna (22), Boris (18)]

4. Typische Fehler bei Suche und Sortierung von Collections

Fehler Nr. 1: Sortieren einer unveränderlichen Liste. Listen, die über List.of(...) erzeugt wurden, dürfen nicht verändert werden – beim Aufruf von sort erhalten Sie eine UnsupportedOperationException.

List<Integer> immutable = List.of(3, 1, 2);
immutable.sort(null); // Wirft eine Exception!

Fehler Nr. 2: Ein Set oder eine Map direkt sortieren. Die Sortiermethoden funktionieren nicht mit Set und Map. Wenn Sie sortieren müssen, wandeln Sie die Daten zuerst in eine Liste um.

Fehler Nr. 3: Falscher Objektvergleich. Subtrahieren Sie bei Vergleichen ganze Zahlen nicht „frontal“ – es kann zu Überläufen kommen. Verwenden Sie statt u1.age - u2.age lieber Integer.compare oder Comparator.comparingInt.

// users.sort((u1, u2) -> u1.age - u2.age); // Funktioniert, ist aber bei Überlauf gefährlich!

Fehler Nr. 4: contains für komplexe Suchen verwenden. Die Methode contains prüft nur exakte Übereinstimmung (über equals). Wenn Sie nach einem Teilstring oder nach einem Feld eines Objekts suchen müssen, verwenden Sie eine Schleife mit Bedingungsprüfung oder Comparatoren/Streams.