Het Collections Framework is Java's geünificeerde set van interfaces en klassen voor het opslaan en manipuleren van groepen objecten — List, Set, Map, Queue, en hun implementaties. Het biedt kant-en-klare, goed geteste datastructuren, dus je hoeft zelden je eigen te bouwen.
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<String> 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-backed, snelle indexering) is de standaard; LinkedList is geschikt voor frequent invoegen aan het einde.
Set<String> 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 biedt O(1) uniciteitschecks; TreeSet houdt elementen gesorteerd.
Map<String, Integer> 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 is het werkpaard voor O(1) sleutel-gebaseerde lookup.
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.
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)
Het Collections Framework is een van de meest gebruikte onderdelen van Java — vrijwel elk programma slaat groepen gegevens ermee op en verwerkt deze.
Het kiezen van de juiste collectie is een kernvaardigheid die direct van invloed is op juistheid en prestaties: ArrayList voor geordende geïndexeerde gegevens, HashSet voor uniciteit, HashMap voor snelle sleutelzoeking, en de gesorteerde/gelijktijdige varianten indien nodig.
Begrip van de interfaces (List/Set/Map/Queue), hun implementaties, en vooral de prestatiekenmerken (O(1) HashMap lookup vs O(n) lijstzoeken) stelt je in staat de passende structuur te kiezen in plaats van standaard voor de verkeerde te kiezen (een veel voorkomende oorzaak van trage code).
Het is fundamentele, praktische kennis voor dagelijkse Java-ontwikkeling.