PricingLoginStart free
Java Academy · Lektion

EnumSet och EnumMap

Använd EnumSet och EnumMap för effektiva typsäkra samlingar baserade på enum-typer.

Lektion 4 av 413 steg

EnumSet och EnumMap är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

EnumSet och EnumMap

EnumSet och EnumMap är mycket optimerade samlingsimplementationer för enumtyper. Internt använder de bitvektorer – de är mycket snabbare än HashSet/HashMap för enumnycklar.

EnumSet: skapa mängder

EnumSet tillhandahåller fabriksmetoder för att skapa mängder av enumkonstanter.

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: mängdoperationer

EnumSet stöder vanliga mängdoperationer – union, snitt och komplement. De är extremt snabba tack vare implementationen med bitvektorer.

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: mappa enumkonstanter till värden

EnumMap använder internt enumens ordinalvärde som ett arrayindex – uppslagning i O(1), snabbare än 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: iterera i ordning

EnumMap itererar alltid över nycklarna i den ordning enumkonstanterna deklarerades – inte i insättningsordning eller hashordning.

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

Behörighetssystem med EnumSet

Ett rollbaserat behörighetssystem som använder EnumSet för effektiva behörighetskontroller och en tydlig API-design.

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-flaggor med EnumMap

EnumMap passar perfekt för system med feature-flaggor: snabb uppslagning i O(1) med enumnycklar.

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

Prestanda: EnumSet jämfört med HashSet

EnumSet använder en enda long-bitmask (för enumtyper med <=64 konstanter) – operationerna är O(1)-bitoperationer. HashSet använder hash-buckets, vilket är långsammare och har större 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

EnumMap getOrDefault och computeIfAbsent

EnumMap stöder alla Map-operationer, inklusive getOrDefault, computeIfAbsent och 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()));
// []

Multimap-mönster med EnumMap

Kombinera EnumMap med List-värden för att skapa en enumnycklad multimap – effektiv gruppering av objekt efter kategori.

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(", "))));

När ska EnumSet respektive EnumMap användas

Sammanfattning av när respektive typ bör väljas:

  • EnumSet: när ni behöver en mängd enumvärden – behörigheter, aktiva funktioner eller valda dagar
  • EnumMap: när varje enumkonstant ska mappas till ett värde – konfiguration per funktion, poäng per nivå eller objekt per kategori
  • Båda: föredra dem framför HashSet/HashMap för enumnycklar – de är snabbare, använder mindre minne och bevarar ordningen

Snabbkontroll

Vilken intern datastruktur använder EnumSet för enumtyper med högst 64 konstanter?

Besvara frågan i den interaktiva lektionen

Repetition: EnumSet och EnumMap

Viktiga punkter:

  • EnumSet använder en bitvektor – extremt snabbt för små enum-mängder
  • EnumSet.of(), range(), allOf() och noneOf() är vanliga fabriksmetoder
  • EnumMap använder ordinalindexerade arrayer – uppslagning i O(1), i deklarationsordning
  • Använd EnumSet för behörighetsmängder, feature-flaggor och filtrering av veckodagar
  • Använd EnumMap för kategorispecifik konfiguration, poängtabeller och mappning från funktion till värde
  • Båda bevarar enumens deklarationsordning och är effektivare än hashbaserade samlingar
Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
104
Lektioner
374
Börja lära dig gratisVisa hela kursen

Vanliga frågor

Är lektionen ”EnumSet och EnumMap” gratis?

Ja – hela texten till ”EnumSet och EnumMap” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”EnumSet och EnumMap”?

Använd EnumSet och EnumMap för effektiva typsäkra samlingar baserade på enum-typer. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”EnumSet och EnumMap”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Definiera och använda enum-typer
  2. Enum-typer med fält och metoder
  3. Switch-uttryck med enum-typer
  4. EnumSet och EnumMap
← Tillbaka till Java Academy