Überblick über Java-Collections – wozu braucht man Collections

1. Einführung

Früher haben wir schon über „unendliche Arrays“ – also Listen – gesprochen. Vertiefen wir unser Wissen und stellen uns noch einmal die Frage, was ein „klassisches“ Array ist. Betrachtet man es genauer, erinnert es an einen Werkzeugkasten mit einer festen Anzahl von Fächern. Angenommen, die Box hat 10 Fächer. Nun kommt ein 11. Werkzeug hinzu – was jetzt? Man muss einen neuen Kasten kaufen! Genauso hat ein herkömmliches Array eine feste Größe; nach der Erstellung ändert sich seine Länge nicht mehr.

Wenn man ein Element hinzufügen oder entfernen muss, muss man ein neues Array anlegen und die Daten per Hand kopieren. In einem Array kann man ein Element schnell per Index finden, aber ein Element in die Mitte einzufügen heißt nicht einfach „einfügen“, sondern „alles nach rechts verschieben“, und beim Entfernen „alles nach links verschieben“. Das ist langsam und unhandlich. Außerdem enthält ein Array keinerlei zusätzliche „Logik“: Es hält nur eine Menge von Zellen; Sortierung, Suche nach Inhalt oder die Prüfung auf Eindeutigkeit müssen extern umgesetzt werden.

Beispiel: dynamische Liste von Studierenden

Angenommen, Sie schreiben eine Anwendung zur Verwaltung von Studierenden in einer Gruppe. Zunächst sind 5 Personen in der Gruppe, dann kommt noch jemand hinzu, später geht jemand. Mit einem Array sähe das so aus:

String[] students = new String[5];
students[0] = "Ivan";
students[1] = "Mariya";
// und so weiter...

// Ups, noch ein Student ist dazugekommen
// Wir müssen ein neues Array erzeugen!
String[] newStudents = new String[6];
for (int i = 0; i < students.length; i++) {
    newStudents[i] = students[i];
}
newStudents[5] = "Aleksey";
students = newStudents;

Bequem? Gelinde gesagt: nein. Und wenn es viele solcher Operationen gibt? Dann wünscht man sich etwas Komfortableres …

2. Was ist eine Collection?

Eine Collection ist ein Objekt, das als Container zum Speichern einer Gruppe anderer Objekte (Elemente) dient. Collections erlauben das Hinzufügen, Entfernen und Iterieren von Elementen sowie weitere Operationen: Suche, Sortierung, Filterung usw.

In Java implementieren alle Collections das Interface Collection oder erben davon (bzw. für Abbildungen – von Map). Eine Collection ist nicht einfach „irgendetwas“, sondern eine Struktur, die einen bequemen, durchdachten Satz von Methoden für die Arbeit mit Elementen bereitstellt.

Warum sind Collections Objekte?

Weil Collections als Klassen implementiert sind. Das heißt, Sie können Collections beliebiger Objekte erstellen, sie kombinieren, erben, erweitern und in Ihren Klassen und Methoden verwenden.

Beispiel:

import java.util.ArrayList;
import java.util.List;

List<String> students = new ArrayList<>();
students.add("Ivan");
students.add("Mariya");
students.add("Aleksey");

Voilà! Jetzt können Sie beliebig viele Studierende hinzufügen, ohne sich um die Array-Größe zu kümmern.

3. Typische Aufgaben, die Collections lösen

Collections sind ein Schweizer Taschenmesser für den Umgang mit Daten. Folgende Aufgaben lassen sich damit lösen:

• Speichern einer dynamischen Datenliste: Zum Beispiel eine Studierendenliste, Aufgaben im Scheduler, Nachrichten im Chat.
• Suche und Filterung: Ein Element schnell finden, seine Existenz prüfen, alle Elemente erhalten, die einer Bedingung entsprechen.
• Sortierung: Elemente nach einem gewünschten Kriterium einfach sortieren.
• Entfernen und Hinzufügen von Elementen: Einfügen und Löschen an beliebigen Positionen ohne manuelles Kopieren von Arrays.
• Gruppierung nach Schlüssel: Zum Beispiel ein Telefonbuch, in dem jedem Namen eine Telefonnummer zugeordnet ist.
• Eindeutigkeit garantieren: Zum Beispiel die Menge aller einzigartigen Wörter in einem Text.

Beispiel: Telefonbuch

Mit einem Array:

• Wie findet man die Nummer zum Namen? Man muss das Array durchlaufen und Namen vergleichen.
• Wie fügt man ein neues Paar hinzu? Man muss das Array vergrößern.
• Wie stellt man sicher, dass Namen nicht doppelt sind? Noch komplizierter.

Mit einer Collection:

• Wir verwenden Map<String, String> – und alles funktioniert „out of the box“.

4. Überblick über die wichtigsten Collection-Typen

In Java lassen sich Collections in drei Hauptgruppen einteilen:

Listen (List)

• Geordnete Collections, erlauben Duplikate.
• Zugriff auf Elemente per Index möglich.
• Beispiele: ArrayList, LinkedList.

Mengen (Set)

• Speichern nur eindeutige Elemente.
• Kein Zugriff per Index.
• Beispiele: HashSet, TreeSet.

Abbildungen (Map)

• Speichern Schlüssel-Wert-Paare.
• Schnelle Suche per Schlüssel.
• Beispiele: HashMap, TreeMap.

Visuelles Schema (stark vereinfacht):

+------------------+       +-------------------+      +---------------------+
|     List         |       |        Set        |      |         Map         |
|------------------|       |-------------------|      |---------------------|
| [a, b, c, d, a]  |       | {a, b, c, d}      |      | {a=1, b=2, c=3}     |
| Indexierung: vorhanden |  | Indexierung: nein |      | Suche per Schlüssel |
| Duplikate: ja    |       | Duplikate: nein   |      | Schlüssel sind eindeutig |
+------------------+       +-------------------+      +---------------------+

5. Nützliche Feinheiten

Wann welche Collection verwenden?

List – wenn die Reihenfolge der Elemente wichtig ist, Duplikate erlaubt sind und Zugriff per Index benötigt wird (z. B. Aufgabenliste, Nachrichtenverlauf).

Set – wenn nur eindeutige Elemente benötigt werden und die Reihenfolge keine Rolle spielt (z. B. Menge einzigartiger Nutzer).

Map – wenn Schlüssel und Werte verknüpft werden sollen (z. B. Telefonbuch, bei dem der Name der Schlüssel und die Nummer der Wert ist).

Alltagsanalogien

List – Schlange in der Mensa: Wer zuerst kommt, wird zuerst bedient; man kann sich auch mehrfach anstellen (Duplikate).

Set – Gästeliste auf einer Party: Jede Person nur einmal (Eindeutigkeit).

Map – Adressbuch: Zu jedem Namen gibt es eine Telefonnummer.

Kurzer Spickzettel: Collections vs. Arrays

6. Bezug der Collections zur OOP

Collections sind Objekte, die bestimmte Interfaces implementieren (List, Set, Map). Das bedeutet, dass Sie:

• Beliebige Objekte in Collections speichern können, einschließlich Instanzen Ihrer eigenen Klassen.
• Collections von Collections erstellen können (z. B. eine Liste von Listen).
• Collections als Parameter und Rückgabewerte von Methoden verwenden können.
• Die Funktionalität von Collections mithilfe von Vererbung und Komposition erweitern können.

Beispiel: Collection von Objekten Ihrer Klasse

import java.util.ArrayList;
import java.util.List;

class Student {
    String name;
    int age;
    // Konstruktor, Getter/Setter usw.
}

public class Main {
    public static void main(String[] args) {
        List<Student> group = new ArrayList<>();
        group.add(new Student("Ivan", 20));
        group.add(new Student("Mariya", 21));
        // und so weiter...
    }
}

7. Typische Fehler beim Arbeiten mit Collections

Fehler Nr. 1: Verwendung von Collections ohne Typparameter (raw types).
Wenn Sie ArrayList list = new ArrayList() schreiben, wird der Compiler beim Hinzufügen beliebiger Objekte (z. B. Strings und Zahlen gemischt) nicht meckern, aber beim Auslesen und Casten zum gewünschten Typ kann zur Laufzeit ein Fehler auftreten (ClassCastException). Verwenden Sie immer Generics: ArrayList<String> list = new ArrayList<>().

Fehler Nr. 2: Benötigte Klasse nicht importiert.
Wenn Sie die Fehlermeldung „cannot find symbol“ sehen, prüfen Sie, ob am Anfang der Datei die Zeile import java.util.ArrayList; steht oder der passende Import für Ihre Collection vorhanden ist.

Fehler Nr. 3: Verwechslung von Collections und Arrays.
Eine Collection ist kein Array! Eine Collection hat kein Feld length, verwenden Sie stattdessen die Methode size(). Ein Array hat keine Methode add(), und eine Collection hat keinen Operator [] für den Indexzugriff (nur Listen über get(index)).

Fehler Nr. 4: Erwartung, dass die Reihenfolge der Elemente immer erhalten bleibt.
Wenn Sie Set oder Map verwenden, ist die Reihenfolge der Elemente nicht garantiert (es sei denn, Sie nutzen spezielle Implementierungen wie LinkedHashSet oder TreeMap). Für geordnete Daten verwenden Sie List oder passende Collections.

Fehler Nr. 5: Verwendung primitiver Typen in Collections.
Collections können nur Objekte speichern, keine primitiven Typen. Man kann also keine List<int> erstellen, nur List<Integer>. Denken Sie an die Wrapper-Klassen!