Was ist das Java Collections Framework?

Question

Accepted Answer

Das **Collections Framework** ist Javas einheitlicher Satz von Schnittstellen und Klassen zum Speichern und Verwalten von Objektgruppen — `List`, `Set`, `Map`, `Queue` und deren Implementierungen. Es bietet vorgefertigte, gut getestete Datenstrukturen, sodass du selten deine eigenen bauen musst. ## Die Kernschnittstellen ```text Collection ├── List — ordered, allows duplicates, indexed access ├── Set — no duplicates, models uniqueness └── Queue — FIFO/priority ordering for processing Map (separate hierarchy) — key→value pairs ``` ## List — geordnet, indiziert, erlaubt Duplikate ```java List list = new ArrayList<>(); // backed by an array — fast random access list.add("a"); list.get(0); // index access — O(1) list.contains("a"); // O(n) search // LinkedList — fast insert/remove at ends, O(n) random access ``` `ArrayList` (array-gestützt, schnelle Indizierung) ist die Standardwahl; `LinkedList` eignet sich für häufiges Einfügen am Ende. ## Set — eindeutige Elemente ```java Set set = new HashSet<>(); // O(1) add/contains, NO order set.add("a"); set.add("a"); // ignored — duplicates not allowed set.contains("a"); // O(1) — great for membership tests // TreeSet — sorted order; LinkedHashSet — insertion order ``` `HashSet` bietet O(1) Eindeutigkeitsprüfungen; `TreeSet` behält Elemente sortiert. ## Map — Schlüssel-Wert-Suche ```java Map map = new HashMap<>(); // O(1) get/put, no order map.put("age", 30); map.get("age"); // 30 map.getOrDefault("x", 0); // safe access with default map.computeIfAbsent("list", k -> new ArrayList<>()); // handy for grouping // TreeMap — sorted by key; LinkedHashMap — insertion order ``` `HashMap` ist das Arbeitstier für O(1) schlüsselgestützte Suche. ## Die richtige Implementierung wählen ```text Need ordered + indexed + duplicates → ArrayList Need uniqueness, fast lookup → HashSet Need key→value, fast lookup → HashMap Need sorted order → TreeSet / TreeMap Need FIFO processing → ArrayDeque / LinkedList (Queue) Need thread-safety → ConcurrentHashMap, etc. ``` ## Big-O ist wichtig ```text ArrayList: get O(1), add-end O(1), contains/remove O(n) HashMap/HashSet: get/put/contains O(1) average TreeMap/TreeSet: O(log n) (sorted) LinkedList: add/remove-ends O(1), get O(n) ``` ## Warum es wichtig ist Das Collections Framework ist einer der am häufigsten verwendeten Teile von Java — nahezu jedes Programm speichert und verarbeitet Datengruppen damit. Die richtige Collection zu wählen ist eine Schlüsselfähigkeit, die Korrektheit und Performance direkt beeinflusst: `ArrayList` für geordnete indizierte Daten, `HashSet` für Eindeutigkeit, `HashMap` für schnelle schlüsselgestützte Suche, und die sortierten/parallelen Varianten bei Bedarf. Die Schnittstellen (List/Set/Map/Queue), ihre Implementierungen und besonders die **Leistungscharakteristiken** (O(1) HashMap-Suche vs. O(n) Listensuche) zu verstehen, ermöglicht dir, die geeignete Struktur zu wählen, anstatt auf die falsche zurückzugreifen (eine häufige Ursache für langsamen Code). Es ist fundamentales, praktisches Wissen für die tägliche Java-Entwicklung.