Maîtriser Java EnumMap : Mapping Clé-Valeur Efficace avec les Enums

Java EnumMap

Dans ce tutoriel, nous apprendrons la classe Java EnumMap et ses opérations avec des exemples.

La classe EnumMap du framework de collections Java fournit une implémentation de map pour les éléments d'un enum.

Dans EnumMap, les éléments d'enum sont utilisés comme clés. Elle implémente l'interface Map.

Création d'un EnumMap

Pour créer un enum map, nous devons d'abord importer le package java.util.EnumMap. Une fois importé, voici comment créer des enum maps en Java.

enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE }
EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);

Dans l'exemple ci-dessus, nous avons créé un enum map nommé sizes.

Ici,

Size - clés de l'enum qui mappent vers des valeurs
Integer - valeurs de l'enum map associées aux clés correspondantes

Méthodes d'EnumMap

La classe EnumMap fournit des méthodes permettant diverses opérations sur les enum maps.

Insérer des Éléments dans EnumMap

put() - insère le mapping clé/valeur (entrée) spécifié dans l'enum map
putAll() - insère toutes les entrées d'une map spécifiée dans cette map

Par exemple,

import java.util.EnumMap;
class Main {
    enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE }
    public static void main(String[] args) {
        // Création d'un EnumMap de l'enum Size
        EnumMap<Size, Integer> sizes1 = new EnumMap<>(Size.class);
        // Utilisation de la méthode put()
        sizes1.put(Size.SMALL, 28);
        sizes1.put(Size.MEDIUM, 32);
        System.out.println("EnumMap1: " + sizes1);
        EnumMap<Size, Integer> sizes2 = new EnumMap<>(Size.class);
        // Utilisation de la méthode putAll()
        sizes2.putAll(sizes1);
        sizes2.put(Size.LARGE, 36);
        System.out.println("EnumMap2: " + sizes2);
    }
}

Sortie

EnumMap1: {SMALL=28, MEDIUM=32} EnumMap2: {SMALL=28, MEDIUM=32, LARGE=36}

Dans l'exemple ci-dessus, nous avons utilisé la méthode putAll() pour insérer tous les éléments d'un enum map sizes1 vers un enum map sizes2.

Il est aussi possible d'insérer des éléments depuis d'autres maps comme HashMap, TreeMap, etc. vers un enum map en utilisant putAll(). Cependant, toutes les maps doivent être du même type d'enum.

Accès aux Éléments d'EnumMap

1. Utilisation de entrySet(), keySet() et values()

entrySet() - retourne un ensemble de tous les mappings clé/valeur (entrée) d'un enum map
keySet() - retourne un ensemble de toutes les clés d'un enum map
values() - retourne un ensemble de toutes les valeurs d'un enum map

Par exemple,

import java.util.EnumMap;
class Main {
    enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE }
    public static void main(String[] args) {
        // Création d'un EnumMap de l'enum Size
        EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
        sizes.put(Size.SMALL, 28);
        sizes.put(Size.MEDIUM, 32);
        sizes.put(Size.LARGE, 36);
        sizes.put(Size.EXTRALARGE, 40);
        System.out.println("EnumMap: " + sizes);
        // Utilisation de la méthode entrySet()
        System.out.println("Mappings Clé/Valeur: " + sizes.entrySet());
        // Utilisation de la méthode keySet()
        System.out.println("Clés: " + sizes.keySet());
        // Utilisation de la méthode values()
        System.out.println("Valeurs: " + sizes.values());
    }
}

Sortie

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} Mappings Clé/Valeur: [SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40] Clés: [SMALL, MEDIUM, LARGE, EXTRALARGE] Valeurs: [28, 32, 36, 40]

2. Utilisation de la Méthode get()

La méthode get() retourne la valeur associée à la clé spécifiée. Elle retourne null si la clé spécifiée n'est pas trouvée.

Par exemple,

import java.util.EnumMap;
class Main {
    enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE }
    public static void main(String[] args) {
        // Création d'un EnumMap de l'enum Size
        EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
        sizes.put(Size.SMALL, 28);
        sizes.put(Size.MEDIUM, 32);
        sizes.put(Size.LARGE, 36);
        sizes.put(Size.EXTRALARGE, 40);
        System.out.println("EnumMap: " + sizes);
        // Utilisation de la méthode get()
        int value = sizes.get(Size.MEDIUM);
        System.out.println("Valeur de MEDIUM: " + value);
    }
}

Sortie

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} Valeur de MEDIUM: 32

Suppression d'Éléments EnumMap

remove(key) - retourne et supprime l'entrée associée à la clé spécifiée de la map
remove(key, value) - supprime l'entrée de la map seulement si la clé spécifiée mappe vers la valeur spécifiée et retourne une valeur booléenne

Par exemple,

import java.util.EnumMap;
class Main {
    enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE }
    public static void main(String[] args) {
        // Création d'un EnumMap de l'enum Size
        EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
        sizes.put(Size.SMALL, 28);
        sizes.put(Size.MEDIUM, 32);
        sizes.put(Size.LARGE, 36);
        sizes.put(Size.EXTRALARGE, 40);
        System.out.println("EnumMap: " + sizes);
        // Utilisation de la méthode remove()
        int value = sizes.remove(Size.MEDIUM);
        System.out.println("Valeur Supprimée: " + value);
        boolean result = sizes.remove(Size.SMALL, 28);
        System.out.println("L'entrée {SMALL=28} est-elle supprimée? " + result);
        System.out.println("EnumMap Mis à Jour: " + sizes);
    }
}

Sortie

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} Valeur Supprimée: 32 L'entrée {SMALL=28} est-elle supprimée? True EnumMap Mis à Jour: {LARGE=36, EXTRALARGE=40}

Remplacement d'Éléments EnumMap

replace(key, value) - remplace la valeur associée à la clé spécifiée par la nouvelle valeur
replace(key, old, new) - remplace l'ancienne valeur par la nouvelle valeur seulement si l'ancienne valeur est déjà associée à la clé spécifiée
replaceAll(function) - remplace chaque valeur de la map avec le résultat de la fonction spécifiée

import java.util.EnumMap;
class Main {
    enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE }
    public static void main(String[] args) {
        // Création d'un EnumMap de l'enum Size
        EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
        sizes.put(Size.SMALL, 28);
        sizes.put(Size.MEDIUM, 32);
        sizes.put(Size.LARGE, 36);
        sizes.put(Size.EXTRALARGE, 40);
        System.out.println("EnumMap: " + sizes);
        // Utilisation de la méthode replace()
        sizes.replace(Size.MEDIUM, 30);
        sizes.replace(Size.LARGE, 36, 34);
        System.out.println("EnumMap avec replace(): " + sizes);
        // Utilisation de la méthode replaceAll()
        sizes.replaceAll((key, oldValue) -> oldValue + 3);
        System.out.println("EnumMap avec replaceAll(): " + sizes);
    }
}

Sortie

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} EnumMap avec replace(): {SMALL=28, MEDIUM=30, LARGE=34, EXTRALARGE=40} EnumMap avec replaceAll(): {SMALL=31, MEDIUM=33, LARGE=37, EXTRALARGE=43}

Dans le programme ci-dessus, remarquez l'instruction

sizes.replaceAll((key, oldValue) -> oldValue + 3);

Ici, la méthode accède à toutes les entrées de la map. Elle remplace ensuite toutes les valeurs par les nouvelles valeurs fournies par les expressions lambda.

Autres Méthodes

Méthode	Description
`clone()`	Crée une copie de l'`EnumMap`
`containsKey()`	Recherche la `EnumMap` pour la clé spécifiée et retourne un résultat booléen
`containsValue()`	Recherche la `EnumMap` pour la valeur spécifiée et retourne un résultat booléen
`size()`	Retourne la taille de l'`EnumMap`
`clear()`	Supprime toutes les entrées de l'`EnumMap`

EnumSet vs EnumMap

Les classes EnumSet et EnumMap fournissent toutes deux des structures de données pour stocker des valeurs d'enum. Cependant, il existe des différences majeures entre elles.

Enum set est représenté en interne comme une séquence de bits, alors que l'enum map est représenté en interne comme des tableaux.
Enum set est créé en utilisant ses méthodes prédéfinies comme allOf(), noneOf(), of(), etc. Cependant, un enum map est créé en utilisant son constructeur.

Interfaces Cloneable et Serializable

La classe EnumMap implémente aussi les interfaces Cloneable et Serializable.

Interface Cloneable

Elle permet à la classe EnumMap de faire une copie des instances de la classe.

Interface Serializable

Chaque fois que des objets Java doivent être transmis sur un réseau, ils doivent être convertis en bits ou octets. C'est parce que les objets Java ne peuvent pas être transmis sur le réseau.

L'interface Serializable permet aux classes d'être sérialisées. Cela signifie que les objets des classes implémentant Serializable peuvent être convertis en bits ou octets.

Java WeakHashMap – Compréhension, Utilisation et Différences Clés Interface Java SortedMap : Aperçu, Méthodes et Implémentation TreeMap

Java