Collections Framework este setul unificat al Java de interfețe și clase pentru stocarea și manipularea grupurilor de obiecte — List, Set, Map, Queue, și implementările lor. Oferă structuri de date gata-făcute, bine testate, astfel încât rar trebuie să-ți construiești propriile.
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 (suportat de tablou, indexare rapidă) este implicit; LinkedList se potrivește pentru inserări frecvente la final.
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 oferă verificări de unicitate O(1); TreeSet ține elementele sortate.
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 este instrumentul de bază pentru căutarea O(1) pe bază de cheie.
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)
Collections Framework este printre cele mai utilizate părți ale Java — aproape fiecare program stochează și procesează grupuri de date cu aceasta.
Alegerea colecției potrivite este o abilitate cheie care afectează direct corectitudinea și performanța: ArrayList pentru date ordonate indexate, HashSet pentru unicitate, HashMap pentru căutări rapide pe bază de cheie, și variantele sortate/concurente când este nevoie.
Înțelegerea interfețelor (List/Set/Map/Queue), implementările lor, și în special caracteristicile de performanță (căutarea O(1) în HashMap vs căutarea O(n) în listă) îți permite să alegi structura potrivită în loc să optezi implicit pentru cea greșită (o cauză comună a codului lent).
Este cunoaștere fundamentală, practică pentru dezvoltarea Java de zi cu zi.