Skip to content

26. Set API

Indice

Un Set in Java rappresenta una collezione che non contiene elementi duplicati.

Modella il concetto matematico di insieme: non ordinato (a meno di usare un’implementazione ordinata) e composto da valori unici.

Tutte le implementazioni di Set si basano su semantiche di uguaglianza (tramite equals() oppure logica di Comparator).

26.1 Gerarchia dei Set (Java Collections Framework)

Set<E>
 ├── SequencedSet<E> (Java 21+)
 │    └── LinkedHashSet<E>   (ordinato)
 ├── HashSet<E>              (non ordinato)
 └── SortedSet<E>
      └── NavigableSet<E>
           └── TreeSet<E>    (ordinato)

Tutte le implementazioni di Set richiedono:

  • unicità degli elementi
  • uguaglianza e hashing prevedibili (a seconda dell’implementazione)

Note

LinkedHashSet è ora formalmente un SequencedSet a partire da Java 21.

26.2 Caratteristiche di Ogni Implementazione di Set

26.2.1 HashSet

  • Set generico più veloce
  • Non ordinato (nessuna garanzia sull’ordine di iterazione)
  • Usa hashCode() ed equals()
  • Consente un solo elemento null 
Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("A");   // duplicato ignorato
System.out.println(set); // ordine non garantito

26.2.2 LinkedHashSet

  • Mantiene l’ordine di inserimento
  • Leggermente più lento di HashSet
  • Utile quando è richiesto un ordine di iterazione prevedibile
Set<String> set = new LinkedHashSet<>();
set.add("A");
set.add("C");
set.add("B");
System.out.println(set);  // [A, C, B]

26.2.3 TreeSet

Un Set ordinato il cui ordine è determinato da:

  • Ordinamento naturale (Comparable)
  • Un Comparator fornito

TreeSet:

  • Non consente elementi null (NullPointerException a runtime)
  • Garantisce iterazione ordinata
  • Supporta viste di intervallo: headSet(), tailSet(), subSet() 
TreeSet<Integer> tree = new TreeSet<>();
tree.add(10);
tree.add(1);
tree.add(5);

System.out.println(tree); // [1, 5, 10]

Note

TreeSet richiede che tutti gli elementi siano mutuamente confrontabili — mescolare tipi non confrontabili produce ClassCastException. Le operazioni (add, remove, contains) sono O(log n).

26.3 Regole di Uguaglianza nei Set

Le regole differiscono in base all’implementazione.

26.3.1 HashSet & LinkedHashSet

L’unicità è determinata da due metodi:

  • hashCode()
  • equals()

Due oggetti sono considerati lo stesso elemento se:

  • I loro hash code coincidono
  • Il loro metodo equals() restituisce true

Warning

Se si muta un oggetto dopo averlo aggiunto a un HashSet o LinkedHashSet, il suo hashCode può cambiare e il set può perdere il riferimento a quell’elemento.

26.3.2 TreeSet

L’unicità è basata su compareTo() o sul Comparator fornito.

Se compare(a, b) == 0 allora gli oggetti sono considerati duplicati, anche se equals() restituisce false.

Comparator<String> comp = (a, b) -> a.length() - b.length();
Set<String> set = new TreeSet<>(comp);

set.add("Hi");
set.add("Yo"); // stessa lunghezza → trattato come duplicato

System.out.println(set);  // ["Hi"]

26.4 Creare Istanze di Set

26.4.1 Usando i Costruttori

Set<String> s1 = new HashSet<>();
Set<String> s2 = new LinkedHashSet<>();
Set<String> s3 = new TreeSet<>();

26.4.2 Costruttori di Copia

List<String> list = List.of("A", "B", "C");

Set<String> copy = new HashSet<>(list); // ordine perso
System.out.println(copy);

Set<String> ordered = new LinkedHashSet<>(list); // mantiene l’ordine della lista
System.out.println(ordered);

26.4.3 Metodi Factory

Set<String> s1 = Set.of("A", "B", "C");   // immutabile
Set<String> empty = Set.of();             // set immutabile vuoto

Note

I set creati tramite factory sono immutabili: aggiungere o rimuovere elementi lancia UnsupportedOperationException. Set.of(...) rifiuta duplicati in fase di creazione → IllegalArgumentException e rifiuta null → NullPointerException

26.5 Operazioni Principali sui Set

26.5.1 Aggiungere Elementi

set.add("A");          // restituisce true se aggiunto
set.add("A");          // restituisce false se duplicato

26.5.2 Verificare l’Appartenenza

set.contains("A");

26.5.3 Rimuovere Elementi

set.remove("A");
set.clear();

26.5.4 Operazioni Bulk

set.addAll(otherSet);
set.removeAll(otherSet);
set.retainAll(otherSet); // intersezione

26.6 Trappole Comuni

  • Usare TreeSet con oggetti non confrontabili → ClassCastException
  • TreeSet non usa affatto equals(): solo comparator/compareTo determina l’unicità
  • Usare oggetti mutabili come chiavi di Set → rompe le regole di hashing
  • I Set creati con Set.of() sono immutabili — la modifica fallisce
  • HashSet non garantisce l’ordine di iterazione
  • TreeSet tratta oggetti con compare()==0 come duplicati anche se non uguali

26.7 Tabella Riassuntiva

Implementazione Mantiene l’Ordine? Consente Null? Ordinato? Logica Sottostante
HashSet No Sì (1 null) No hashCode + equals
LinkedHashSet Sì (ordine di inserimento) Sì (1 null) No tabella hash + lista collegata
TreeSet Sì (ordinato) No Sì (naturale/comparator) compareTo / Comparator