Java Academy · Leçon

EnumSet et EnumMap

Utilisez EnumSet et EnumMap pour gérer efficacement des collections d’énumérations avec vérification des types.

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

EnumSet et EnumMap

EnumSet et EnumMap sont des implémentations de collections hautement optimisées pour les énumérations. Elles utilisent en interne des vecteurs de bits, bien plus rapides que HashSet/HashMap pour les clés d’énumération.

EnumSet : créer des ensembles

EnumSet fournit des méthodes de fabrique permettant de créer des ensembles de constantes d’énumération.

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 : opérations sur les ensembles

EnumSet prend en charge les opérations classiques sur les ensembles : union, intersection et complément. Elles sont extrêmement rapides grâce à l’implémentation sous forme de vecteur de bits.

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 : associer des énumérations à des valeurs

EnumMap utilise en interne l’ordinal de l’énumération comme index de tableau : la recherche en O(1) est plus rapide qu’avec 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 : parcourir dans l’ordre

EnumMap parcourt toujours les clés dans l’ordre de déclaration de l’énumération, et non dans l’ordre d’insertion ou de hachage.

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

Système d’autorisations avec EnumSet

Un système d’autorisations fondé sur les rôles, utilisant EnumSet pour effectuer efficacement les contrôles d’autorisations et proposer une interface claire.

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

Indicateurs de fonctionnalité avec EnumMap

EnumMap est idéal pour les systèmes d’indicateurs de fonctionnalité : recherche rapide en O(1) avec des clés d’énumération.

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

Performances : EnumSet contre HashSet

EnumSet utilise un masque de bits unique de type long (pour les énumérations comportant au plus 64 constantes) : ses opérations sur les bits sont en O(1). HashSet utilise des compartiments de hachage, ce qui est plus lent et entraîne davantage de surcharge.

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

EnumMap prend en charge toutes les opérations de mappage, notamment getOrDefault, computeIfAbsent et la fusion.

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()));
// []

Motif de mappage multiple avec EnumMap

Associez EnumMap à des valeurs de type List pour créer un mappage multiple indexé par une énumération et regrouper efficacement les éléments par catégorie.

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

Quand utiliser EnumSet ou EnumMap

Voici quand choisir chacun :

EnumSet : lorsque vous avez besoin d’un ensemble de valeurs d’énumération : autorisations, fonctionnalités actives ou jours sélectionnés
EnumMap : lorsque vous associez chaque constante d’énumération à une valeur : configuration par fonctionnalité, score par niveau ou éléments par catégorie
Les deux : préférez-les à HashSet/HashMap pour les clés d’énumération : ils sont plus rapides, utilisent moins de mémoire et conservent l’ordre

Vérification rapide

Quelle structure de données interne EnumSet utilise-t-il pour les énumérations comportant au plus 64 constantes ?

Récapitulatif : EnumSet et EnumMap

À retenir :

EnumSet utilise un vecteur de bits, extrêmement rapide pour les petits ensembles d’énumérations
EnumSet.of(), range(), allOf() et noneOf() sont des méthodes de fabrique courantes
EnumMap utilise des tableaux indexés par l’ordinal : recherche en O(1), dans l’ordre de déclaration
Utilisez EnumSet pour les ensembles d’autorisations, les indicateurs de fonctionnalité et le filtrage des jours de la semaine
Utilisez EnumMap pour la configuration par catégorie, les tables de scores et l’association d’une fonctionnalité à une valeur
Les deux respectent l’ordre de déclaration de l’énumération et sont plus efficaces que les collections fondées sur le hachage

Questions Fréquemment Posées

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

Oui — le texte complet de « EnumSet et 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 « EnumSet et EnumMap » ?

Utilisez EnumSet et EnumMap pour gérer efficacement des collections d’énumérations avec vérification des types. 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 « EnumSet et 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