Il Collections Framework è il set unificato di interfacce e classi di Java per immagazzinare e manipolare gruppi di oggetti — List, Set, Map, Queue e le loro implementazioni. Fornisce strutture dati già pronte e ben testate, quindi raramente devi costruire le tue.
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 (supportato da array, indicizzazione veloce) è quello predefinito; LinkedList è adatto per frequenti inserimenti alla fine.
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 offre controlli di unicità O(1); TreeSet mantiene gli elementi ordinati.
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 è il cavallo di battaglia per la ricerca O(1) basata su chiave.
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)
Il Collections Framework è tra le parti più utilizzate di Java — quasi tutti i programmi immagazzinano ed elaborano gruppi di dati con esso.
Scegliere la giusta collection è un'abilità chiave che influisce direttamente su correttezza e prestazioni: ArrayList per i dati ordinati indicizzati, HashSet per l'unicità, HashMap per ricerche rapide per chiave, e le varianti ordinate/concurrent quando necessario.
Comprendere le interfacce (List/Set/Map/Queue), le loro implementazioni e specialmente le caratteristiche di prestazione (ricerca O(1) di HashMap vs ricerca O(n) di list) ti consente di scegliere la struttura appropriata piuttosto che optare per quella sbagliata (una causa comune di codice lento).
È una conoscenza fondamentale e pratica per lo sviluppo quotidiano di Java.