Java Collections Cheatsheet

6 Kernkonzepte

Die wichtigsten Collections in Java: List · Set · Map · Queue · Collections · Legacy Das Java Collections Framework bietet leistungsstarke Datenstrukturen für die Speicherung und Verarbeitung von Objekten – von geordneten Listen über eindeutige Sets bis zu Schlüssel-Wert-Maps.

List – Geordnete Sammlungen

ArrayList · LinkedList · Vector

List<String> list = new ArrayList<>(); list.add("Apfel"); String first = list.get(0);

List ist eine geordnete Sammlung, die Duplikate erlaubt. Der Zugriff erfolgt über den Index. ArrayList ist die am häufigsten verwendete Implementierung.

Wichtige List-Methoden

Methode	Beschreibung
add(E e)	Fügt Element am Ende hinzu
add(int index, E e)	Fügt Element an Position ein
get(int index)	Gibt Element an Position zurück
set(int index, E e)	Ersetzt Element an Position
remove(int index)	Entfernt Element an Position
remove(Object o)	Entfernt erstes Vorkommen
size()	Gibt Anzahl der Elemente zurück
contains(Object o)	Prüft, ob Element enthalten ist
indexOf(Object o)	Gibt Position des Elements zurück
toArray()	Konvertiert zu Array

Beispiele

import java.util.*;

List<String> fruits = new ArrayList<>();

fruits.add("Apfel");

fruits.add("Banane");

fruits.add("Kirsche");

System.out.println(fruits.get(0)); // Apfel

System.out.println(fruits.size()); // 3

// Iteration

for (String f : fruits) {

System.out.println(f);

}

// Mit Index

for (int i = 0; i < fruits.size(); i++) {

System.out.println(fruits.get(i));

}

Tipp: ArrayList ist für schnellen Zugriff per Index optimiert, LinkedList für häufiges Einfügen/Löschen am Anfang der Liste.

Set – Eindeutige Elemente

HashSet · TreeSet · LinkedHashSet

Set<Integer> set = new HashSet<>(); set.add(1); set.add(2); set.add(1); // wird ignoriert (Duplikat)

Set ist eine Sammlung, die keine Duplikate enthält. Die Reihenfolge ist nicht garantiert (außer bei TreeSet und LinkedHashSet).

Set-Implementierungen

Klasse	Beschreibung
HashSet	Schnellste Implementierung, keine Reihenfolge (O(1))
TreeSet	Sortierte Reihenfolge (O(log n)), implementiert NavigableSet
LinkedHashSet	Einfügereihenfolge beibehalten, O(1)
EnumSet	Speziell für Enum-Typen, sehr effizient

Beispiele

import java.util.*;

Set<String> names = new HashSet<>();

names.add("Anna");

names.add("Ben");

names.add("Anna"); // Duplikat wird ignoriert

System.out.println(names.size()); // 2

System.out.println(names.contains("Ben")); // true

// TreeSet (sortiert)

Set<Integer> sorted = new TreeSet<>();

sorted.add(5); sorted.add(1); sorted.add(3);

System.out.println(sorted); // [1, 3, 5]

// Iteration

for (String name : names) {

System.out.println(name);

}

Tipp: HashSet ist die beste Wahl für die meisten Anwendungsfälle. TreeSet ist ideal, wenn Sie sortierte Daten benötigen.

Map – Schlüssel-Wert-Paare

HashMap · TreeMap · LinkedHashMap

Map<String, Integer> map = new HashMap<>(); map.put("Anna", 30); int age = map.get("Anna");

Map speichert Schlüssel-Wert-Paare. Jeder Schlüssel ist eindeutig und kann zum Abrufen des zugehörigen Werts verwendet werden.

Wichtige Map-Methoden

Methode	Beschreibung
put(K key, V value)	Fügt ein Schlüssel-Wert-Paar hinzu
get(Object key)	Gibt den Wert für den Schlüssel zurück
getOrDefault(key, defaultValue)	Gibt Wert oder Default zurück (Java 8+)
remove(Object key)	Entfernt das Paar mit dem Schlüssel
containsKey(Object key)	Prüft, ob Schlüssel vorhanden ist
containsValue(Object value)	Prüft, ob Wert vorhanden ist
keySet()	Gibt alle Schlüssel als Set zurück
values()	Gibt alle Werte als Collection zurück
entrySet()	Gibt alle Paare als Set zurück
putIfAbsent(key, value)	Fügt hinzu, wenn Schlüssel nicht vorhanden (Java 8+)
computeIfAbsent(key, mapping)	Berechnet Wert, falls Schlüssel fehlt (Java 8+)

Beispiele

import java.util.*;

Map<String, Integer> user = new HashMap<>();

user.put("id", 1);

user.put("age", 30);

System.out.println(user.get("id")); // 1

System.out.println(user.getOrDefault("name", 0)); // 0

// Iteration über Einträge

for (Map.Entry<String, Integer> entry : user.entrySet()) {

System.out.println(entry.getKey() + ": " + entry.getValue());

}

// computeIfAbsent (Java 8+)

Map<String, List<String>> groups = new HashMap<>();

groups.computeIfAbsent("A", k -> new ArrayList<>()).add("Benutzer1");

Tipp: Verwenden Sie computeIfAbsent() oder getOrDefault() für elegante Null-Check-Vermeidung. HashMap ist die schnellste Map-Implementierung.

Queue – Warteschlangen

PriorityQueue · LinkedList · ArrayDeque

Queue<String> queue = new PriorityQueue<>(); queue.offer("Erster"); String first = queue.poll();

Queue ist eine Warteschlange nach dem FIFO-Prinzip (First-In-First-Out) oder mit Priorität. PriorityQueue sortiert nach natürlicher Ordnung oder Comparator.

Wichtige Queue-Methoden

Methode	Beschreibung	Exception bei Fehler
add(e)	Fügt Element hinzu	IllegalStateException
offer(e)	Fügt Element hinzu (bevorzugt)	false
remove()	Entfernt und gibt Kopf zurück	NoSuchElementException
poll()	Entfernt und gibt Kopf zurück (bevorzugt)	null
element()	Gibt Kopf zurück (ohne Entfernen)	NoSuchElementException
peek()	Gibt Kopf zurück (ohne Entfernen, bevorzugt)	null
size()	Anzahl der Elemente	-

Beispiele

import java.util.*;

// FIFO-Queue mit LinkedList

Queue<String> queue = new LinkedList<>();

queue.offer("Aufgabe 1");

queue.offer("Aufgabe 2");

queue.offer("Aufgabe 3");

while (!queue.isEmpty()) {

System.out.println(queue.poll());

}

// PriorityQueue (natürliche Ordnung)

Queue<Integer> pq = new PriorityQueue<>();

pq.add(5); pq.add(1); pq.add(3);

System.out.println(pq.poll()); // 1

System.out.println(pq.poll()); // 3

System.out.println(pq.poll()); // 5

Tipp: Verwenden Sie offer() und poll() statt add() und remove() – sie werfen keine Exceptions und sind daher robuster.

Collections – Utility-Methoden

sort · reverse · shuffle · binarySearch

Collections.sort(list); Collections.reverse(list); Collections.binarySearch(list, "key");

Collections ist eine Utility-Klasse mit statischen Methoden für die Arbeit mit Collections – Sortieren, Suchen, Mischen und mehr.

Wichtige Collections-Methoden

Methode	Beschreibung
sort(List list)	Sortiert Liste nach natürlicher Ordnung
sort(List list, Comparator c)	Sortiert Liste mit Comparator
reverse(List list)	Kehrt die Reihenfolge der Liste um
shuffle(List list)	Mischt die Liste zufällig
binarySearch(list, key)	Binäre Suche (Liste muss sortiert sein)
min(Collection coll)	Kleinstes Element (nach natürlicher Ordnung)
max(Collection coll)	Größtes Element (nach natürlicher Ordnung)
frequency(Collection c, Object o)	Zählt Vorkommen eines Objekts
unmodifiableList(List list)	Gibt unveränderbare Liste zurück
synchronizedList(List list)	Gibt threadsichere Liste zurück

Beispiele

import java.util.*;

List<Integer> numbers = new ArrayList<>();

numbers.addAll(Arrays.asList(5, 2, 8, 1, 3));

// Sortieren

Collections.sort(numbers);

System.out.println(numbers); // [1, 2, 3, 5, 8]

// Umkehren

Collections.reverse(numbers);

System.out.println(numbers); // [8, 5, 3, 2, 1]

// Binäre Suche (Liste muss sortiert sein!)

Collections.sort(numbers);

int index = Collections.binarySearch(numbers, 3);

System.out.println(index); // 2

Tipp: Collections.binarySearch() setzt eine sortierte Liste voraus, sonst ist das Ergebnis undefiniert. Verwenden Sie es für effiziente Suchen in großen Listen.

Legacy – Veraltete Collections

Vector · Stack · Hashtable · Enumeration

// Veraltet – nicht mehr verwenden! Vector<String> v = new Vector<>(); Hashtable<String, String> ht = new Hashtable<>();

Legacy-Klassen sind veraltete Collections aus den frühen Java-Versionen. Sie sind synchronisiert (thread-safe) aber langsam. Verwenden Sie stattdessen die modernen Äquivalente.

Legacy vs. Modern

Legacy	Modern	Bemerkung
Vector	ArrayList	Vector ist synchronisiert (langsamer)
Stack	Deque (ArrayDeque)	Stack erbt von Vector (veraltet)
Hashtable	HashMap	Hashtable ist synchronisiert, erlaubt kein null
Enumeration	Iterator	Enumeration ist veraltet
Dictionary	Map	Dictionary ist veraltet

Beispiele

// NICHT VERWENDEN! (Legacy)

Vector<String> v = new Vector<>();

v.add("Element");

Hashtable<String, Integer> ht = new Hashtable<>();

ht.put("key", 123);

// STATTDESSEN VERWENDEN:

List<String> list = new ArrayList<>();

list.add("Element");

Map<String, Integer> map = new HashMap<>();

map.put("key", 123);

⚠️ Achtung: Vector, Stack, Hashtable und Enumeration gelten als veraltet. Verwenden Sie stattdessen ArrayList, ArrayDeque, HashMap und Iterator.

Java Collections im Überblick

List Geordnet, Duplikate erlaubt
ArrayList, LinkedList

Set Eindeutig, keine Duplikate
HashSet, TreeSet

Map Schlüssel-Wert-Paare
HashMap, TreeMap

Queue FIFO / Priorität
PriorityQueue, ArrayDeque

Collections Utility-Methoden
sort, reverse, binarySearch

Legacy Veraltet (nicht verwenden)
Vector, Hashtable

Quick Summary

List

ArrayList, LinkedList

Set

HashSet, TreeSet

Map

HashMap, TreeMap

Queue

PriorityQueue

Collections

sort, binarySearch

Legacy

⚠️ Veraltet

List<String> list = new ArrayList<>(); · Set<Integer> set = new HashSet<>(); · Map<K,V> map = new HashMap<>();