Java Academy · Lektion

EnumSet und EnumMap

Verwenden Sie EnumSet und EnumMap für effiziente, typsichere Enum-basierte Collections.

EnumSet und EnumMap ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

EnumSet und EnumMap

EnumSet und EnumMap sind hochoptimierte Collection-Implementierungen für Enums. Intern verwenden sie Bitvektoren und sind für Enum-Schlüssel deutlich schneller als HashSet/HashMap.

EnumSet: Mengen erstellen

EnumSet stellt Factory-Methoden zum Erstellen von Mengen aus Enum-Konstanten bereit.

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: Mengenoperationen

EnumSet unterstützt die üblichen Mengenoperationen – Vereinigung, Schnitt und Komplement. Dank der Implementierung mit Bitvektoren sind diese Operationen extrem schnell.

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: Enums auf Werte abbilden

EnumMap verwendet intern das Enum-Ordinal als Array-Index – der Zugriff in O(1) ist schneller als bei 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: In Reihenfolge iterieren

EnumMap iteriert Schlüssel immer in der Deklarationsreihenfolge des Enums – nicht in Einfügungs- oder Hash-Reihenfolge.

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

Berechtigungssystem mit EnumSet

Ein rollenbasiertes Berechtigungssystem, das EnumSet für effiziente Berechtigungsprüfungen und ein übersichtliches API-Design verwendet.

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-Flags mit EnumMap

EnumMap eignet sich hervorragend für Feature-Flag-Systeme: schneller Zugriff in O(1) mit Enum-Schlüsseln.

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

Performance: EnumSet vs. HashSet

EnumSet verwendet eine einzelne Bitmaske vom Typ long (für Enums mit höchstens 64 Konstanten) – die Operationen bestehen aus Bitoperationen in O(1). HashSet verwendet Hash-Buckets und ist durch den höheren Overhead langsamer.

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 und computeIfAbsent

EnumMap unterstützt alle Map-Operationen, einschließlich getOrDefault, computeIfAbsent und 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-Muster mit EnumMap

Kombinieren Sie EnumMap mit List-Werten, um eine Multimap mit Enum-Schlüsseln zu erstellen – für eine effiziente Gruppierung von Elementen nach Kategorie.

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

Wann Sie EnumSet bzw. EnumMap verwenden sollten

Zusammenfassung der jeweiligen Einsatzbereiche:

EnumSet: wenn Sie eine Menge von Enum-Werten benötigen – etwa für Berechtigungen, aktive Funktionen oder ausgewählte Wochentage
EnumMap: wenn Sie jede Enum-Konstante einem Wert zuordnen – etwa Konfigurationen pro Funktion, Punktzahlen pro Stufe oder Elemente pro Kategorie
Beide: Verwenden Sie sie für Enum-Schlüssel bevorzugt gegenüber HashSet/HashMap – sie sind schneller, benötigen weniger Speicher und behalten die Reihenfolge bei

Kurztest

Welche interne Datenstruktur verwendet EnumSet für Enums mit höchstens 64 Konstanten?

Zusammenfassung: EnumSet und EnumMap

Die wichtigsten Erkenntnisse:

EnumSet verwendet einen Bitvektor und ist für kleine Enum-Mengen extrem schnell
EnumSet.of(), range(), allOf() und noneOf() sind häufig verwendete Factory-Methoden
EnumMap verwendet ordinalbasierte Arrays – Zugriff in O(1), sortiert nach Deklarationsreihenfolge
Verwenden Sie EnumSet für Berechtigungsmengen, Feature-Flags und die Filterung nach Wochentagen
Verwenden Sie EnumMap für Konfigurationen pro Kategorie, Bewertungstabellen und Zuordnungen von Funktionen zu Werten
Beide behalten die Deklarationsreihenfolge des Enums bei und sind effizienter als Hash-basierte Collections

Häufig gestellte Fragen

Ist die Lektion „EnumSet und EnumMap“ kostenlos?

Ja — der vollständige Text von „EnumSet und EnumMap“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „EnumSet und EnumMap“?

Verwenden Sie EnumSet und EnumMap für effiziente, typsichere Enum-basierte Collections. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „EnumSet und EnumMap“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy