0Pricing
Java Academy · Lezione

TreeMap: coppie chiave-valore ordinate

Utilizzi TreeMap per mantenere l'ordine ordinato e spostarsi con firstKey, lastKey, floorKey e ceilingKey.

TreeMap: coppie chiave-valore ordinate è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 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'è TreeMap?

TreeMap è un'implementazione di mappa ordinata basata su un albero rosso-nero. Le chiavi vengono mantenute nell'ordine naturale crescente (o nell'ordine definito da un comparatore personalizzato). Tutte le operazioni di base sono O(log n).

import java.util.TreeMap;

TreeMap<String, Integer> scores = new TreeMap<>();
scores.put("Charlie", 85);
scores.put("Alice", 92);
scores.put("Bob", 78);

// Iteration is in key order: Alice, Bob, Charlie
for (var entry : scores.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

firstKey, lastKey, floorKey, ceilingKey

L'interfaccia NavigableMap di TreeMap espone metodi di navigazione per trovare chiavi relative a un determinato valore:

TreeMap<Integer, String> map = new TreeMap<>();
map.put(10, "ten"); map.put(20, "twenty"); map.put(30, "thirty"); map.put(40, "forty");

System.out.println(map.firstKey());       // 10
System.out.println(map.lastKey());        // 40
System.out.println(map.floorKey(25));     // 20 (largest key ≤ 25)
System.out.println(map.ceilingKey(25));   // 30 (smallest key ≥ 25)
System.out.println(map.lowerKey(20));     // 10 (strictly less)
System.out.println(map.higherKey(20));    // 30 (strictly greater)

Navigazione tra le entry

floorEntry, ceilingEntry, firstEntry, lastEntry restituiscono l'intera Map.Entry invece della sola chiave:

TreeMap<Integer, String> prices = new TreeMap<>();
prices.put(100, "Budget"); prices.put(300, "Standard"); prices.put(700, "Premium");

var entry = prices.floorEntry(350);
System.out.println(entry.getKey() + ": " + entry.getValue()); // 300: Standard

var top = prices.lastEntry();
System.out.println(top.getValue()); // Premium

subMap, headMap, tailMap

Estragga viste di intervalli da una TreeMap. Queste viste sono collegate alla mappa originale: le modifiche apportate a una si riflettono nell'altra.

TreeMap<Integer, String> map = new TreeMap<>();
for (int i = 1; i <= 10; i++) map.put(i, "v"+i);

// Keys from 3 (inclusive) to 7 (exclusive)
System.out.println(map.subMap(3, 7));   // {3=v3, 4=v4, 5=v5, 6=v6}

// Keys strictly less than 5
System.out.println(map.headMap(5));     // {1=v1, 2=v2, 3=v3, 4=v4}

// Keys >= 7
System.out.println(map.tailMap(7));     // {7=v7, 8=v8, 9=v9, 10=v10}

Limiti inclusivi ed esclusivi

Utilizzi le varianti sovraccaricate per controllare con precisione i limiti:

TreeMap<Integer, String> map = new TreeMap<>();
for (int i = 1; i <= 10; i++) map.put(i*10, "v"+i);

// From 30 (inclusive) to 60 (inclusive)
System.out.println(map.subMap(30, true, 60, true));
// {30=v3, 40=v4, 50=v5, 60=v6}

Ordine decrescente

Utilizzi descendingMap() o descendingKeySet() per iterare sulle chiavi in ordine inverso:

TreeMap<String, Integer> tm = new TreeMap<>();
tm.put("A", 1); tm.put("C", 3); tm.put("B", 2);

for (String key : tm.descendingKeySet()) {
    System.out.print(key + " "); // C B A
}

pollFirstEntry e pollLastEntry

Rimuova e restituisca atomicamente la prima o l'ultima entry: è utile per creare mappe di priorità:

TreeMap<Integer, String> events = new TreeMap<>();
events.put(8, "Breakfast");
events.put(12, "Lunch");
events.put(18, "Dinner");

var first = events.pollFirstEntry(); // removes 8=Breakfast
System.out.println(first.getValue() + " removed");
System.out.println(events.firstKey()); // 12

Caso d'uso: classifica

Una classifica deve ordinare i giocatori in base al punteggio. TreeMap ordina automaticamente in base alla chiave:

TreeMap<Integer, String> leaderboard = new TreeMap<>(Comparator.reverseOrder());
leaderboard.put(1200, "Alice");
leaderboard.put(1500, "Bob");
leaderboard.put(900, "Carol");

int rank = 1;
for (var e : leaderboard.entrySet()) {
    System.out.println(rank++ + ". " + e.getValue() + " (" + e.getKey() + ")");
}
// 1. Bob (1500)
// 2. Alice (1200)
// 3. Carol (900)

Caso d'uso: pianificazione degli eventi

Associare i timestamp agli eventi: utilizzi ceilingEntry per trovare il prossimo evento pianificato dopo un determinato orario:

import java.time.LocalTime;
TreeMap<LocalTime, String> schedule = new TreeMap<>();
schedule.put(LocalTime.of(9,0), "Standup");
schedule.put(LocalTime.of(14,0), "Review");
schedule.put(LocalTime.of(17,0), "Retro");

LocalTime now = LocalTime.of(11, 30);
var next = schedule.ceilingEntry(now);
System.out.println("Next: " + next.getValue()); // Review

Prestazioni di TreeMap e HashMap a confronto

Confronto tra le chiavi:

  • HashMap: get/put mediamente in O(1); non ordinata
  • TreeMap: get/put in O(log n); ordinata in base alla chiave
  • LinkedHashMap: mediamente in O(1); ordinata secondo l'inserimento

Utilizzi TreeMap quando sono necessarie chiavi ordinate o query su intervalli. HashMap è più veloce per le semplici ricerche per chiave.

Thread safety

TreeMap NON è thread-safe. Per l'accesso concorrente, utilizzi ConcurrentSkipListMap, che mantiene anch'essa l'ordine ordinato con operazioni in O(log n) e supporta letture e scritture concorrenti.

Verifica rapida

Si dispone di una TreeMap<Integer, String> con le chiavi {10, 20, 30, 40}. Che cosa restituisce map.floorKey(25)?

Riepilogo: TreeMap

Punti chiave:

  • TreeMap mantiene le chiavi in ordine ordinato (crescente) tramite un albero rosso-nero
  • Tutte le operazioni sono O(log n)
  • Navigazione: firstKey, lastKey, floorKey, ceilingKey, lowerKey, higherKey
  • Viste di intervalli: subMap, headMap, tailMap (viste collegate)
  • Utilizzi ConcurrentSkipListMap per mappe ordinate thread-safe

Domande Frequenti

La lezione «TreeMap: coppie chiave-valore ordinate» è gratuita?

Sì — il testo completo di «TreeMap: coppie chiave-valore ordinate» è 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 «TreeMap: coppie chiave-valore ordinate»?

Utilizzi TreeMap per mantenere l'ordine ordinato e spostarsi con firstKey, lastKey, floorKey e ceilingKey. 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 1 di 4.

Quanto tempo richiede la lezione «TreeMap: coppie chiave-valore ordinate»?

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