Java Academy · Leçon

EnumMap

Tables efficaces indexées par une énumération

EnumMap est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce qu'EnumMap ?

EnumMap est une implémentation spécialisée de Map dont les clés sont les constantes d'un seul type d'énumération.

En interne, il repose sur un simple tableau indexé par l'ordinal de la constante. Les recherches et les insertions sont ainsi extrêmement rapides, sans hachage.

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

La construction nécessite la classe

Un EnumMap doit connaître à l'avance le type de ses clés ; son constructeur reçoit donc l'objet de classe : new EnumMap<>(Day.class).

C'est ainsi qu'il dimensionne son tableau interne selon le nombre de constantes.

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

Rapidité fondée sur un tableau

Comme les clés sont stockées à l'emplacement array[ordinal], get et put correspondent à des accès directs au tableau, plus rapides que le hachage et le parcours des compartiments de HashMap.

Aucune conversion des clés en objets n'est nécessaire et aucun appel à hashCode n'est effectué.

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

Parcours dans l'ordre des clés

EnumMap parcourt ses entrées dans l'ordre naturel des clés, c'est-à-dire leur ordre de déclaration.

Les sorties sont ainsi stables et prévisibles, contrairement à celles de 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());
        }
    }
}

Les clés nulles sont interdites

EnumMap n'autorise pas les clés nulles ; une clé nulle déclenche NullPointerException.

Les valeurs nulles sont autorisées, comme dans les autres maps.

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

Regroupement avec EnumMap

Un usage courant consiste à compter ou à regrouper les éléments par catégorie d'énumération. merge permet de compter les occurrences de manière concise.

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

Toutes les méthodes par défaut standard de Map fonctionnent. getOrDefault évite les vérifications de valeurs nulles, tandis que computeIfAbsent construit les valeurs à la demande.

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

Constructeur de copie

EnumMap possède un constructeur de copie qui accepte une autre Map. Si la source est un EnumMap, le type des clés est déduit à partir de celle-ci.

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 et tableaux indexés par ordinal

Avant EnumMap, on utilisait des tableaux bruts indexés par ordinal(). Cette approche est fragile et peu sûre.

EnumMap offre la même rapidité que les tableaux, avec la sécurité de typage, la vérification des limites et une interface Map claire.

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

EnumMaps imbriquées

Vous pouvez imbriquer des EnumMaps pour modéliser une matrice indexée par deux énumérations, comme une table de transitions d'état.

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

Choisir le type approprié

Règle générale :

Si les clés sont des constantes d'énumération et que vous voulez une structure associative, utilisez EnumMap.
Si vous voulez un ensemble d'énumérations, utilisez EnumSet.
Si les clés sont des objets quelconques, utilisez 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);
    }
}

Vérification rapide

Vérifiez vos connaissances sur EnumMap.

Récapitulatif

Vous avez découvert EnumMap :

Une Map fondée sur un tableau, dont les clés sont des constantes d'énumération.
Le constructeur reçoit la classe des clés ; les clés nulles sont interdites.
Le parcours respecte l'ordre de déclaration.
Le remplacement sûr et rapide des tableaux indexés par ordinal.

Vous avez terminé le cours avancé sur les énumérations.

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

Questions Fréquemment Posées

La leçon « EnumMap » est-elle gratuite ?

Oui — le texte complet de « EnumMap » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « EnumMap » ?

Tables efficaces indexées par une énumération Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « EnumMap » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Java Academy