0Pricing
Java Academy · Lezione

TreeSet e NavigableSet

Memorizzi elementi univoci e ordinati e utilizzi floor, ceiling, higher e lower per le ricerche dei valori più vicini.

TreeSet e NavigableSet è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Che cos'è TreeSet?

TreeSet è un insieme ordinato basato su un albero rosso-nero. Memorizza elementi univoci in ordine naturale crescente (o secondo un comparatore fornito). Tutte le operazioni sono O(log n).

import java.util.TreeSet;

TreeSet<String> names = new TreeSet<>();
names.add("Charlie");
names.add("Alice");
names.add("Bob");
names.add("Alice"); // duplicate ignored

for (String s : names) System.out.print(s + " ");
// Alice Bob Charlie

Metodi di NavigableSet: floor, ceiling, lower, higher

TreeSet implementa NavigableSet e fornisce metodi di navigazione per trovare gli elementi più vicini:

TreeSet<Integer> set = new TreeSet<>();
for (int i = 10; i <= 50; i += 10) set.add(i);
// {10, 20, 30, 40, 50}

System.out.println(set.floor(25));   // 20 (greatest ≤ 25)
System.out.println(set.ceiling(25)); // 30 (smallest ≥ 25)
System.out.println(set.lower(30));   // 20 (strictly less)
System.out.println(set.higher(30));  // 40 (strictly greater)

first, last, pollFirst, pollLast

Acceda agli elementi ai limiti oppure li rimuova:

TreeSet<String> ts = new TreeSet<>(Set.of("cherry","apple","banana","date"));

System.out.println(ts.first());       // apple
System.out.println(ts.last());        // date
System.out.println(ts.pollFirst());   // apple (removed)
System.out.println(ts.pollLast());    // date (removed)
System.out.println(ts);              // [banana, cherry]

headSet, tailSet, subSet

Estragga viste di sottoinsiemi ordinati:

TreeSet<Integer> set = new TreeSet<>(Set.of(1,2,3,4,5,6,7,8,9,10));

System.out.println(set.headSet(5));      // [1, 2, 3, 4]
System.out.println(set.tailSet(7));      // [7, 8, 9, 10]
System.out.println(set.subSet(3, 7));    // [3, 4, 5, 6]

// Inclusive upper bound:
System.out.println(set.subSet(3, true, 7, true)); // [3,4,5,6,7]

Iterazione in ordine decrescente

Utilizzi descendingIterator() o descendingSet() per ottenere l'ordine inverso:

TreeSet<Integer> ts = new TreeSet<>(Set.of(1,3,5,7,9));

// Descending iterator
var it = ts.descendingIterator();
while (it.hasNext()) System.out.print(it.next() + " ");
// 9 7 5 3 1

Ordinamento personalizzato tramite Comparator

Passi un Comparator per ordinare secondo un criterio diverso da quello naturale, ad esempio dalla stringa più lunga alla più corta:

TreeSet<String> byLength = new TreeSet<>(
    Comparator.comparingInt(String::length)
              .thenComparing(Comparator.naturalOrder())
);
byLength.add("Hi");
byLength.add("Hello");
byLength.add("Hey");
byLength.add("Java");

for (String s : byLength) System.out.print(s + " ");
// Hi Hey Java Hello

Caso d'uso: nomi utente univoci ordinati

Memorizzi i nomi utente in un TreeSet per rimuovere automaticamente i duplicati e mantenerli in ordine alfabetico:

TreeSet<String> users = new TreeSet<>();
users.add("alice");
users.add("bob");
users.add("alice"); // ignored
users.add("carol");

System.out.println(users.first()); // alice
System.out.println(users);         // [alice, bob, carol]

Caso d'uso: conteggio in un intervallo

Conti gli elementi in un intervallo utilizzando subSet:

TreeSet<Integer> scores = new TreeSet<>();
for (int s : new int[]{45,62,78,55,90,88,34,71}) scores.add(s);

// Scores between 60 and 89 (inclusive)
int count = scores.subSet(60, true, 89, true).size();
System.out.println("Students in B range: " + count); // 3 (62, 78, 88... wait: 62,78,71,88=4)
// Actually: 62,71,78,88 = 4

TreeSet, HashSet e LinkedHashSet a confronto

Scelga in base alle esigenze:

  • HashSet: operazioni in O(1), non ordinato
  • LinkedHashSet: operazioni in O(1), ordinato secondo l'inserimento
  • TreeSet: operazioni in O(log n), ordine ordinato, metodi di navigazione

TreeSet richiede che gli elementi implementino Comparable o che venga fornito un Comparator.

Elementi null

TreeSet NON consente elementi null quando utilizza l'ordinamento naturale: viene generata una NullPointerException perché null non può essere confrontato. Sarebbe possibile utilizzare un comparatore personalizzato che gestisca esplicitamente null.

TreeSet<String> ts = new TreeSet<>();
try {
    ts.add(null); // throws NullPointerException
} catch (NullPointerException e) {
    System.out.println("Cannot add null: " + e);
}

Thread safety

TreeSet NON è thread-safe. Sincronizzi l'accesso esternamente con Collections.synchronizedSortedSet() oppure utilizzi ConcurrentSkipListSet, che è ordinato e thread-safe.

Verifica rapida

Un TreeSet<Integer> contiene {10, 20, 30, 40, 50}. Che cosa restituisce set.ceiling(35)?

Riepilogo: TreeSet e NavigableSet

Punti chiave:

  • TreeSet memorizza elementi univoci e ordinati (O(log n))
  • Implementa NavigableSet: floor, ceiling, lower, higher, first, last
  • headSet, tailSet e subSet restituiscono viste di intervalli collegate
  • Utilizzi descendingSet()/descendingIterator() per l'ordine inverso
  • Non è thread-safe: utilizzi ConcurrentSkipListSet per la concorrenza

Domande Frequenti

La lezione «TreeSet e NavigableSet» è gratuita?

Sì — il testo completo di «TreeSet e NavigableSet» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «TreeSet e NavigableSet»?

Memorizzi elementi univoci e ordinati e utilizzi floor, ceiling, higher e lower per le ricerche dei valori più vicini. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «TreeSet e NavigableSet»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. TreeMap: coppie chiave-valore ordinate
  2. Sottomappe e viste di intervallo
  3. TreeSet e NavigableSet
  4. Ordinamento personalizzato nelle collezioni ad albero
← Torna a Java Academy