EnumMap
Mappe efficienti con chiavi enum
EnumMap è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 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'è EnumMap?
EnumMap è una Map specializzata le cui chiavi sono costanti di un singolo tipo enum.
Internamente si basa su un semplice array indicizzato tramite l'ordinal della costante. Questo rende estremamente veloci le ricerche e gli inserimenti, senza ricorrere all'hashing.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum Day { MON, TUE, WED }
public static void main(String[] args) {
Map<Day, String> plan = new EnumMap<>(Day.class);
plan.put(Day.MON, "Gym");
plan.put(Day.WED, "Swim");
System.out.println(plan);
}
}Per la costruzione serve la classe
Un EnumMap deve conoscere in anticipo il tipo delle chiavi, quindi il costruttore riceve l'oggetto Class: new EnumMap<>(Day.class).
In questo modo può dimensionare il proprio array interno in base al numero di costanti.
import java.util.EnumMap;
public class Main {
enum Priority { LOW, MEDIUM, HIGH }
public static void main(String[] args) {
EnumMap<Priority, Integer> counts = new EnumMap<>(Priority.class);
counts.put(Priority.HIGH, 5);
System.out.println(counts.get(Priority.HIGH));
}
}Velocità basata sugli array
Poiché le chiavi sono memorizzate in array[ordinal], get e put sono accessi diretti all'array, più veloci dell'hashing e della scansione dei bucket di HashMap.
Non viene effettuato il boxing della chiave e non viene chiamato hashCode.
import java.util.EnumMap;
public class Main {
enum Slot { A, B, C, D }
public static void main(String[] args) {
EnumMap<Slot, Integer> m = new EnumMap<>(Slot.class);
for (Slot s : Slot.values()) m.put(s, s.ordinal() * 10);
System.out.println(m.get(Slot.C));
}
}Iterazione nell'ordine delle chiavi
EnumMap esegue l'iterazione delle entry secondo l'ordine naturale delle chiavi, cioè il loro ordine di dichiarazione.
Questo produce un output stabile e prevedibile, a differenza di HashMap.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum Phase { PLAN, BUILD, SHIP }
public static void main(String[] args) {
Map<Phase, Integer> hours = new EnumMap<>(Phase.class);
hours.put(Phase.SHIP, 3);
hours.put(Phase.PLAN, 8);
hours.put(Phase.BUILD, 20);
for (Map.Entry<Phase, Integer> e : hours.entrySet()) {
System.out.println(e.getKey() + " = " + e.getValue());
}
}
}Le chiavi null non sono consentite
EnumMap non consente chiavi null; una chiave null genera NullPointerException.
I valori null sono consentiti, come nelle altre map.
import java.util.EnumMap;
public class Main {
enum K { A, B }
public static void main(String[] args) {
EnumMap<K, String> m = new EnumMap<>(K.class);
m.put(K.A, null); // null value is fine
System.out.println("A -> " + m.get(K.A));
System.out.println("contains A: " + m.containsKey(K.A));
}
}Raggruppare con EnumMap
Un uso comune consiste nel contare o raggruppare in base a una categoria enum. merge rende conciso il conteggio.
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
public class Main {
enum Type { FRUIT, VEG, MEAT }
record Item(String name, Type type) {}
public static void main(String[] args) {
List<Item> items = List.of(new Item("apple", Type.FRUIT), new Item("pear", Type.FRUIT), new Item("beef", Type.MEAT));
Map<Type, Integer> counts = new EnumMap<>(Type.class);
for (Item i : items) counts.merge(i.type(), 1, Integer::sum);
System.out.println(counts);
}
}getOrDefault e computeIfAbsent
Tutti i metodi default standard di Map funzionano correttamente. getOrDefault evita i controlli sui valori null e computeIfAbsent costruisce i valori in modo lazy.
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
public class Main {
enum Group { A, B }
public static void main(String[] args) {
Map<Group, List<String>> m = new EnumMap<>(Group.class);
m.computeIfAbsent(Group.A, k -> new ArrayList<>()).add("first");
System.out.println(m);
System.out.println(m.getOrDefault(Group.B, List.of()));
}
}Costruttore di copia
EnumMap dispone di un costruttore di copia che accetta un'altra Map. Se la sorgente è un EnumMap, il tipo delle chiavi viene dedotto da essa.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum K { X, Y }
public static void main(String[] args) {
EnumMap<K, Integer> a = new EnumMap<>(K.class);
a.put(K.X, 1);
EnumMap<K, Integer> b = new EnumMap<>(a);
b.put(K.Y, 2);
System.out.println("copy: " + b);
}
}EnumMap rispetto agli array basati su ordinal
Prima di EnumMap, si usavano array grezzi indicizzati tramite ordinal(). Questo approccio è fragile e non sicuro.
EnumMap offre la stessa velocità degli array, con sicurezza dei tipi, sicurezza dei limiti e una API Map pulita.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum Season { SPRING, SUMMER, FALL, WINTER }
public static void main(String[] args) {
Map<Season, String> mood = new EnumMap<>(Season.class);
mood.put(Season.SUMMER, "sunny");
// Safer and clearer than String[] indexed by ordinal
System.out.println(mood.get(Season.SUMMER));
}
}EnumMap annidati
È possibile annidare EnumMap per modellare una matrice indicizzata da due enum, ad esempio una tabella delle transizioni di stato.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum State { SOLID, LIQUID, GAS }
enum Transition { MELT, FREEZE }
public static void main(String[] args) {
Map<State, Map<Transition, State>> table = new EnumMap<>(State.class);
Map<Transition, State> solid = new EnumMap<>(Transition.class);
solid.put(Transition.MELT, State.LIQUID);
table.put(State.SOLID, solid);
System.out.println(table.get(State.SOLID).get(Transition.MELT));
}
}Scegliere il tipo giusto
Regola generale:
- Se le chiavi sono costanti enum e desidera una map, utilizzi EnumMap.
- Se desidera un set di enum, utilizzi EnumSet.
- Se le chiavi sono oggetti arbitrari, utilizzi HashMap.
import java.util.EnumMap;
import java.util.Map;
public class Main {
enum Level { DEBUG, INFO, WARN, ERROR }
public static void main(String[] args) {
Map<Level, Integer> thresholds = new EnumMap<>(Level.class);
for (Level l : Level.values()) thresholds.put(l, l.ordinal() * 100);
System.out.println(thresholds);
}
}Verifica rapida
Verifichi la Sua conoscenza di EnumMap.
Riepilogo
Ha imparato a usare EnumMap:
- Una Map basata su un array e indicizzata tramite costanti enum.
- Il costruttore riceve la Class delle chiavi; le chiavi null non sono consentite.
- Esegue l'iterazione nell'ordine di dichiarazione.
- L'alternativa sicura e veloce agli array indicizzati tramite ordinal.
Ha completato il corso avanzato sugli enum.
import java.util.EnumMap;
public class Main {
enum K { A }
public static void main(String[] args) {
EnumMap<K, String> m = new EnumMap<>(K.class);
m.put(K.A, "done");
System.out.println("EnumMap course complete: " + m.get(K.A));
}
}Domande Frequenti
La lezione «EnumMap» è gratuita?
Sì — il testo completo di «EnumMap» è 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 «EnumMap»?
Mappe efficienti con chiavi enum 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 4 di 4.
Quanto tempo richiede la lezione «EnumMap»?
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.