0Pricing
Java Academy · Lezione

EnumSet ed EnumMap

Utilizzi EnumSet ed EnumMap per gestire collezioni basate su enum efficienti e sicure rispetto ai tipi.

EnumSet ed 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.

EnumSet ed EnumMap

EnumSet ed EnumMap sono implementazioni di collezioni per enum altamente ottimizzate. Internamente utilizzano vettori di bit, risultando molto più veloci di HashSet/HashMap per le chiavi enum.

EnumSet: creare insiemi

EnumSet fornisce metodi factory per creare insiemi di costanti enum.

import java.util.*;

enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }

EnumSet<Day> weekdays  = EnumSet.range(Day.MON, Day.FRI);
EnumSet<Day> weekend   = EnumSet.of(Day.SAT, Day.SUN);
EnumSet<Day> allDays   = EnumSet.allOf(Day.class);
EnumSet<Day> noDays    = EnumSet.noneOf(Day.class);

System.out.println(weekdays); // [MON, TUE, WED, THU, FRI]
System.out.println(weekend);  // [SAT, SUN]
System.out.println(allDays.size()); // 7

EnumSet: operazioni sugli insiemi

EnumSet supporta le operazioni standard sugli insiemi: unione, intersezione e complemento. Queste operazioni sono estremamente veloci grazie all'implementazione basata su vettori di bit.

import java.util.*;

enum Permission { READ, WRITE, DELETE, ADMIN, EXPORT }

EnumSet<Permission> userPerms  = EnumSet.of(Permission.READ, Permission.WRITE);
EnumSet<Permission> adminPerms = EnumSet.allOf(Permission.class);

// Complement
EnumSet<Permission> missing = EnumSet.complementOf(userPerms);
System.out.println("Missing: " + missing);
// Missing: [DELETE, ADMIN, EXPORT]

// Intersection (retain)
EnumSet<Permission> shared = EnumSet.copyOf(userPerms);
shared.retainAll(adminPerms);
System.out.println("Shared: " + shared); // [READ, WRITE]

EnumMap: associare enum a valori

EnumMap utilizza internamente l'ordinale dell'enum come indice di un array: la ricerca O(1) è più veloce di quella di HashMap.

import java.util.*;

enum Quarter { Q1, Q2, Q3, Q4 }

EnumMap<Quarter, Double> revenue = new EnumMap<>(Quarter.class);
revenue.put(Quarter.Q1, 125_000.0);
revenue.put(Quarter.Q2, 148_500.0);
revenue.put(Quarter.Q3, 132_750.0);
revenue.put(Quarter.Q4, 175_200.0);

double total = revenue.values().stream()
    .mapToDouble(Double::doubleValue).sum();
System.out.printf("Annual revenue: $%.0f%n", total);
// Annual revenue: $581450

EnumMap: iterare nell'ordine

EnumMap itera sempre sulle chiavi nell'ordine di dichiarazione dell'enum, non nell'ordine di inserimento o nell'ordine hash.

import java.util.*;

enum Month { JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC }

EnumMap<Month, Integer> salesUnits = new EnumMap<>(Month.class);
salesUnits.put(Month.MAR, 1420);
salesUnits.put(Month.JAN, 980);
salesUnits.put(Month.FEB, 1105);

// Iterates JAN, FEB, MAR (declaration order, not insertion order)
for (var entry : salesUnits.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
// JAN: 980
// FEB: 1105
// MAR: 1420

Sistema di autorizzazioni con EnumSet

Un sistema di autorizzazioni basato sui ruoli che utilizza EnumSet per verifiche efficienti dei permessi e una progettazione chiara dell'API.

import java.util.*;

enum Permission { READ, WRITE, DELETE, PUBLISH, ADMIN }

record Role(String name, EnumSet<Permission> permissions) {
    boolean can(Permission p) { return permissions.contains(p); }
}

Role editor = new Role("Editor",
    EnumSet.of(Permission.READ, Permission.WRITE, Permission.PUBLISH));
Role viewer = new Role("Viewer",
    EnumSet.of(Permission.READ));

System.out.println(editor.can(Permission.WRITE));  // true
System.out.println(viewer.can(Permission.DELETE)); // false

Feature flag con EnumMap

EnumMap è perfetto per i sistemi di feature flag: ricerca O(1) rapida con chiavi enum.

import java.util.*;

enum Feature { DARK_MODE, BETA_EDITOR, AI_SUGGESTIONS, EXPORT_PDF }

class FeatureFlags {
    private final EnumMap<Feature, Boolean> flags = new EnumMap<>(Feature.class);

    public FeatureFlags() {
        for (Feature f : Feature.values()) flags.put(f, false);
    }

    public void enable(Feature f)  { flags.put(f, true); }
    public void disable(Feature f) { flags.put(f, false); }
    public boolean isEnabled(Feature f) { return flags.getOrDefault(f, false); }
}

FeatureFlags ff = new FeatureFlags();
ff.enable(Feature.DARK_MODE);
System.out.println(ff.isEnabled(Feature.DARK_MODE));      // true
System.out.println(ff.isEnabled(Feature.AI_SUGGESTIONS)); // false

Prestazioni: EnumSet rispetto a HashSet

EnumSet utilizza una singola maschera di bit long (per enum con <=64 costanti): le operazioni sono operazioni su bit O(1). HashSet utilizza bucket hash, risultando più lento e con maggiore overhead.

import java.util.*;

enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }

// EnumSet: bit operations on a long value
EnumSet<Day> workDays = EnumSet.range(Day.MON, Day.FRI);

// HashSet: hash table with boxing overhead
Set<Day> hashWorkDays = new HashSet<>(Arrays.asList(
    Day.MON, Day.TUE, Day.WED, Day.THU, Day.FRI));

// Both work, but EnumSet is ~5x faster for contains/add/remove
// and uses less memory
System.out.println(workDays.contains(Day.SAT));     // false
System.out.println(workDays.contains(Day.MON));     // true

getOrDefault e computeIfAbsent di EnumMap

EnumMap supporta tutte le operazioni di Map, inclusi getOrDefault, computeIfAbsent e merge.

import java.util.*;

enum Category { FOOD, ELECTRONICS, CLOTHING, BOOKS }

EnumMap<Category, List<String>> catalog = new EnumMap<>(Category.class);

// computeIfAbsent creates the list on first use
catalog.computeIfAbsent(Category.BOOKS, k -> new ArrayList<>()).add("Clean Code");
catalog.computeIfAbsent(Category.BOOKS, k -> new ArrayList<>()).add("Effective Java");
catalog.computeIfAbsent(Category.ELECTRONICS, k -> new ArrayList<>()).add("Laptop");

System.out.println(catalog.get(Category.BOOKS));
// [Clean Code, Effective Java]
System.out.println(catalog.getOrDefault(Category.FOOD, List.of()));
// []

Pattern multimap con EnumMap

Combini EnumMap con valori List per creare una multimap indicizzata da enum, utile per raggruppare in modo efficiente gli elementi per categoria.

import java.util.*;
import java.util.stream.*;

enum Priority { LOW, NORMAL, HIGH, URGENT }
record Task(String name, Priority priority) {}

List<Task> tasks = List.of(
    new Task("Fix login bug", Priority.URGENT),
    new Task("Update docs",   Priority.LOW),
    new Task("Add unit tests",Priority.NORMAL),
    new Task("Deploy hotfix", Priority.URGENT)
);

// Group by priority into EnumMap
EnumMap<Priority, List<Task>> byPriority = tasks.stream()
    .collect(Collectors.groupingBy(Task::priority,
        () -> new EnumMap<>(Priority.class),
        Collectors.toList()));

byPriority.forEach((p, ts) ->
    System.out.println(p + ": " + ts.stream().map(Task::name).collect(Collectors.joining(", "))));

Quando usare EnumSet rispetto a EnumMap

Riepilogo della scelta più adatta:

  • EnumSet: quando serve un insieme di valori enum, ad esempio per autorizzazioni, feature attive o giorni selezionati
  • EnumMap: quando si associa ogni costante enum a un valore, ad esempio per la configurazione di ogni feature, il punteggio di ogni livello o gli elementi di ogni categoria
  • Entrambi: da preferire a HashSet/HashMap per le chiavi enum: sono più veloci, usano meno memoria e mantengono l'ordine

Verifica rapida

Qual è la struttura dati interna utilizzata da EnumSet per enum con 64 o meno costanti?

Riepilogo: EnumSet ed EnumMap

Punti chiave:

  • EnumSet utilizza un vettore di bit, estremamente veloce per gli insiemi enum di piccole dimensioni
  • EnumSet.of(), range(), allOf() e noneOf() sono metodi factory comuni
  • EnumMap utilizza array indicizzati tramite ordinale: ricerca O(1), con ordine di dichiarazione
  • Utilizzi EnumSet per insiemi di autorizzazioni, feature flag e filtri sui giorni della settimana
  • Utilizzi EnumMap per configurazioni per categoria, tabelle di punteggi e associazioni tra feature e valori
  • Entrambi mantengono l'ordine di dichiarazione dell'enum e sono più efficienti delle collezioni basate su hash

Domande Frequenti

La lezione «EnumSet ed EnumMap» è gratuita?

Sì — il testo completo di «EnumSet ed 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 «EnumSet ed EnumMap»?

Utilizzi EnumSet ed EnumMap per gestire collezioni basate su enum efficienti e sicure rispetto ai tipi. 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 «EnumSet ed 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.

Tutte le lezioni di questo corso

  1. Definizione e utilizzo degli enum
  2. Enum con campi e metodi
  3. Espressioni switch con gli enum
  4. EnumSet ed EnumMap
← Torna a Java Academy