Schnittstellen Collection, List, Set, Map: Hierarchie

1. Was ist das Interface Collection

In Java ist ein Interface wie ein Vertrag: Wenn eine Klasse ein Interface implementiert, muss sie eine Implementierung aller seiner Methoden bereitstellen. Ein Interface speichert selbst keinen Zustand und enthält keinen Code (fast: seit Java 8 sind default-Methoden möglich, hier zählt jedoch die Grundidee).

Collection – das Basis-Interface für die meisten Collections in Java. Es legt fest, was eine Collection kann: Elemente hinzufügen, entfernen, die Größe ermitteln, das Vorhandensein von Elementen prüfen usw.

public interface Collection<E> extends Iterable<E> {
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    boolean add(E e);
    boolean remove(Object o);
    void clear();
    Iterator<E> iterator();
    // ... und noch eine Menge nützlicher Methoden
}

Schlüsselmethoden:

• add(E e) – Element hinzufügen.
• remove(Object o) – Element entfernen.
• size() – Anzahl der Elemente ermitteln.
• isEmpty() – prüfen, ob die Collection leer ist.
• contains(Object o) – Vorhandensein eines Elements prüfen.
• clear() – Collection leeren.
• iterator() – Iterator zum Durchlaufen erhalten.

Warum erbt Map nicht von Collection?

Map steht unter den Collections für sich. Denn Map ist eine Menge von „Schlüssel → Wert“-Paaren und nicht einfach eine Menge von Elementen. Sie hat eine andere Semantik und einen anderen Methodensatz. So gibt es in Map z. B. keine Methode add, weil das Hinzufügen über put(key, value) erfolgt; und es ergibt keinen Sinn, das Vorhandensein eines Werts zu prüfen, ohne den Schlüssel zu kennen.

2. Hierarchie der Collections

Das gedankliche „Baum“-Diagramm der wichtigsten Interfaces sieht so aus:

                Iterable
                   |
               Collection
               /    |    \
            List   Set   Queue
                          |
                        Deque

• Iterable – das grundlegendste Interface: alles, was man in einer for-each-Schleife durchlaufen kann.
• Collection – erweitert Iterable und fügt Operationen für die Arbeit mit einer Menge von Elementen hinzu.
• Drei Hauptzweige:
  • List – geordnete Liste, erlaubt Duplikate.
  • Set – Menge einzigartiger Elemente; die Reihenfolge hängt von der Implementierung ab.
  • Queue – Warteschlange (in der Regel FIFO); Unterart – Deque (beidseitige Warteschlange).

Und Map lebt separat:

                Map
               /   \
         HashMap  TreeMap

Visualisierung der Hierarchie (Schema)

                            +--------------------+
                            |     Iterable<E>    |
                            +--------------------+
                                     |
                            +--------------------+
                            |   Collection<E>    |
                            +--------------------+
                          /     |         \
                +--------+   +-------+   +-------+
                |  List  |   |  Set |   | Queue |
                +--------+   +-------+   +-------+
                                     |
                                  +------+
                                  |Deque |
                                  +------+

        +--------------------+
        |      Map<K,V>      |
        +--------------------+

3. List: geordnete Collection mit Duplikaten

List ist eine Collection, bei der:

• die Reihenfolge der Elemente wichtig ist (erstes, zweites, drittes …).
• gleiche Elemente (Duplikate) zulässig sind.
• man ein Element per Index (list.get(2)) abrufen, ersetzen und an beliebiger Stelle einfügen kann.

Beispiele für Implementierungen: ArrayList – schneller Zugriff per Index; LinkedList – gut bei häufigen Einfügungen/Löschungen in der Mitte.

import java.util.*;

List<String> shoppingList = new ArrayList<>();
shoppingList.add("Milch");
shoppingList.add("Brot");
shoppingList.add("Käse");
shoppingList.add("Brot"); // Duplikate sind erlaubt!

System.out.println(shoppingList.get(1)); // "Brot"

Typische List-Methoden:

• add(E e), add(int index, E e)
• get(int index), set(int index, E e)
• remove(int index), remove(Object o)
• indexOf(Object o), lastIndexOf(Object o)

4. Set: Menge einzigartiger Elemente

Set ist eine Collection, bei der:

• jedes Element einzigartig ist (keine Duplikate).
• bei HashSet keine Reihenfolge garantiert ist; es kann eine Sortierung bei TreeSet geben oder die Einfügereihenfolge bei LinkedHashSet.

Beispiele für Implementierungen: HashSet, TreeSet, LinkedHashSet.

import java.util.*;

Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Anja");
uniqueNames.add("Boris");
uniqueNames.add("Anja"); // Wird nicht hinzugefügt – ist bereits vorhanden!

System.out.println(uniqueNames.contains("Anja")); // true
System.out.println(uniqueNames.size()); // 2

Typische Set-Methoden:

• add(E e), remove(Object o)
• contains(Object o)
• size(), isEmpty()

5. Map: Sammlung von Schlüssel-Wert-Paaren

Map ist eine Collection, bei der:

• jedes Element ein Schlüssel → Wert-Paar ist.
• Schlüssel eindeutig sind, Werte sich wiederholen dürfen.
• schneller Zugriff über den Schlüssel möglich ist.

Beispiele für Implementierungen: HashMap, TreeMap, LinkedHashMap.

import java.util.*;

Map<String, String> phoneBook = new HashMap<>();
phoneBook.put("Anja", "+19991112233");
phoneBook.put("Boris", "+19994445566");
phoneBook.put("Anja", "+19990001122"); // Überschreibt Anjas Nummer!

System.out.println(phoneBook.get("Anja")); // "+19990001122"
System.out.println(phoneBook.containsKey("Boris")); // true

Typische Map-Methoden:

• put(K key, V value), get(K key)
• remove(K key)
• containsKey(K key), containsValue(V value)
• keySet(), values(), entrySet()

6. Visualisierung der Hierarchie: alles auf einen Blick

Eine kleine Zusammenfassungstabelle:

List

ArrayList, LinkedList

Set

HashSet, TreeSet

Map

HashMap, TreeMap

Hierarchie im Schema:

                Collection
                /    |    \
             List   Set   Queue
                            |
                          Deque

                Map (separat)

7. Wann welches Interface verwenden

List

• Wenn die Reihenfolge der Elemente wichtig ist (z. B. Verlauf der Benutzeraktionen).
• Wenn Duplikate benötigt werden (z. B. Bestellpositionen).
• Wenn schneller Zugriff/Ersetzen per Index gefragt ist.

Set

• Wenn Eindeutigkeit erforderlich ist (E-Mail, Logins, IDs).
• Wenn die Reihenfolge unwichtig ist – oder im Gegenteil eine automatisch sortierte Menge benötigt wird (TreeSet).

Map

• Wenn Schlüssel und Werte zugeordnet werden sollen (ID → Objekt, Login → Profil).
• Wenn schnelle Suche nach dem Schlüssel erforderlich ist.
• Wenn Schlüssel eindeutig sein müssen, Werte jedoch nicht.

8. Typische Fehler im Umgang mit der Collections-Hierarchie

Fehler Nr. 1: Falsches Interface in der Variablendeklaration. Wenn Sie ArrayList<String> list = new ArrayList<>(); schreiben, koppeln Sie sich hart an die Implementierung. Besser ist List<String> list = new ArrayList<>(); – so lässt sich die Implementierung leichter austauschen.

Fehler Nr. 2: Duplikate in ein Set einfügen und erwarten, dass sie erscheinen. Das ist kein Bug, sondern ein Merkmal: Set speichert per Definition keine Duplikate. Eine erneute Einfügung wird ignoriert.

Fehler Nr. 3: Map wie eine normale Collection verwenden. Map ist weder Liste noch Menge. Zum Durchlaufen verwenden Sie keySet(), values() oder entrySet().

Fehler Nr. 4: Eine Reihenfolge in HashSet oder HashMap erwarten. HashSet und HashMap garantieren keine Reihenfolge. Wenn sie wichtig ist – nehmen Sie LinkedHashSet oder LinkedHashMap.

Fehler Nr. 5: List für eindeutige Elemente verwenden. Wenn Eindeutigkeit erforderlich ist – verwenden Sie Set. List verhindert keine Duplikate.