Java Academy · Lektion

EnumMap

Effiziente Maps mit Enum-Schlüsseln

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.

Was ist EnumMap?

EnumMap ist eine spezialisierte Map, deren Schlüssel Konstanten eines einzigen Enum-Typs sind.

Intern basiert sie auf einem einfachen Array, das über den Ordinalwert der Konstante indiziert wird. Dadurch sind Nachschlagen und Einfügen extrem schnell und kommen ohne Hashing aus.

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);
    }
}

Für die Erstellung ist Class erforderlich

Ein EnumMap muss den Schlüsseltyp im Voraus kennen, daher erwartet der Konstruktor das Class-Objekt: new EnumMap<>(Day.class).

So kann das interne Array auf die Anzahl der Konstanten dimensioniert werden.

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));
    }
}

Geschwindigkeit dank Array-Unterstützung

Da Schlüssel unter array[ordinal] gespeichert werden, sind get und put direkte Arrayzugriffe und schneller als das Hashing und das Durchlaufen von Buckets in einer HashMap.

Es gibt kein Boxing des Schlüssels und keinen Aufruf von 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));
    }
}

Iteration in Schlüsselreihenfolge

EnumMap durchläuft Einträge in der natürlichen Reihenfolge der Schlüssel, also in deren Deklarationsreihenfolge.

Dadurch ist die Ausgabe stabil und vorhersehbar, anders als bei 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());
        }
    }
}

Null-Schlüssel sind nicht erlaubt

EnumMap erlaubt keine Null-Schlüssel; ein Null-Schlüssel löst NullPointerException aus.

Nullwerte sind wie bei anderen Maps erlaubt.

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));
    }
}

Gruppieren mit EnumMap

Eine häufige Verwendung ist das Zählen oder Gruppieren nach einer Enum-Kategorie. Mit merge lässt sich zählen, ohne viel Code zu schreiben.

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

Alle standardmäßigen Default-Methoden von Map funktionieren. getOrDefault erspart Nullprüfungen, und computeIfAbsent erstellt Werte bei Bedarf.

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()));
    }
}

Kopierkonstruktor

EnumMap besitzt einen Kopierkonstruktor, der eine andere Map akzeptiert. Wenn die Quelle ein EnumMap ist, wird der Schlüsseltyp daraus abgeleitet.

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 im Vergleich zu ordinalbasierten Arrays

Vor EnumMap verwendete man rohe Arrays, die über ordinal() indiziert wurden. Das ist fragil und unsicher.

EnumMap bietet dieselbe Array-Geschwindigkeit mit Typsicherheit, sicherer Bereichsprüfung und einer übersichtlichen Map-API.

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));
    }
}

Verschachtelte EnumMaps

Sie können EnumMaps verschachteln, um eine Matrix abzubilden, deren Schlüssel aus zwei Enums bestehen, beispielsweise eine Tabelle für Zustandsübergänge.

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));
    }
}

Den richtigen Typ wählen

Als Faustregel gilt:

Die Schlüssel sind Enum-Konstanten und Sie möchten eine Map: Verwenden Sie EnumMap.
Sie möchten eine Menge von Enums: Verwenden Sie EnumSet.
Die Schlüssel sind beliebige Objekte: Verwenden Sie 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);
    }
}

Kurzer Test

Testen Sie Ihr Wissen über EnumMap.

Zusammenfassung

Sie haben EnumMap gelernt:

Eine arraybasierte Map mit Enum-Konstanten als Schlüsseln.
Der Konstruktor erwartet die Schlüssel-Class; Null-Schlüssel sind nicht erlaubt.
Die Iteration erfolgt in Deklarationsreihenfolge.
Der sichere und schnelle Ersatz für ordinalbasierte Arrays.

Sie haben den Kurs zu fortgeschrittenen Enums abgeschlossen.

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));
    }
}

Häufig gestellte Fragen

Ist die Lektion „EnumMap“ kostenlos?

Ja — der vollständige Text von „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 „EnumMap“?

Effiziente Maps mit Enum-Schlüsseln 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 „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