Java EnumMap

Carte d'énumération Java

Dans ce didacticiel, nous allons découvrir la classe Java EnumMap et ses opérations à l'aide d'exemples.

Le EnumMap La classe du framework de collections Java fournit une implémentation de carte pour les éléments d'une énumération.

En EnumMap , les éléments enum sont utilisés comme clés . Il implémente l'interface Map.

Avant d'en savoir plus sur EnumMap , assurez-vous de connaître les énumérations Java.

Créer une EnumMap

Afin de créer une carte enum, nous devons importer le java.util.EnumMap paquet d'abord. Une fois que nous avons importé le package, voici comment nous pouvons créer des cartes enum en Java.

enum Size {
    SMALL, MEDIUM, LARGE, EXTRALARGE
}

EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);

Dans l'exemple ci-dessus, nous avons créé une carte enum nommée sizes .

Ici,

Taille - clés de l'énumération qui correspond aux valeurs
Entier - valeurs de la carte enum associée aux clés correspondantes

Méthodes d'EnumMap

Le EnumMap La classe fournit des méthodes qui nous permettent d'effectuer divers éléments sur les cartes enum.

Insérer des éléments dans EnumMap

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

Par exemple,

import java.util.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        EnumMap<Size, Integer> sizes1 = new EnumMap<>(Size.class);

        // Using the put() Method
        sizes1.put(Size.SMALL, 28);
        sizes1.put(Size.MEDIUM, 32);
        System.out.println("EnumMap1: " + sizes1);

        EnumMap<Size, Integer> sizes2 = new EnumMap<>(Size.class);

        // Using the putAll() Method
        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é le putAll() méthode pour insérer tous les éléments d'une carte enum sizes1 à une carte enum de sizes2 .

Il est également possible d'insérer des éléments d'autres cartes comme HashMap , TreeMap , etc. à une carte enum en utilisant putAll() . Cependant, toutes les cartes doivent être du même type enum.

Accéder aux éléments EnumMap

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

entrySet() - renvoie un ensemble de tous les mappages clés/valeurs (entrée) d'une carte enum
keySet() - renvoie un ensemble de toutes les clés d'une carte enum
values() - renvoie un ensemble de toutes les valeurs d'une carte enum

Par exemple,

import java.util.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the entrySet() Method
        System.out.println("Key/Value mappings: " + sizes.entrySet());

        // Using the keySet() Method
        System.out.println("Keys: " + sizes.keySet());

        // Using the values() Method
        System.out.println("Values: " + sizes.values());
    }
}

Sortie

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Key/Value mappings: [SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40]
Keys: [SMALL, MEDIUM, LARGE, EXTRALARGE]
Values: [28, 32, 36, 40]

2. Utilisation de la méthode get()

Le get() La méthode renvoie la valeur associée à la clé spécifiée. Il renvoie null si la clé spécifiée est introuvable.

Par exemple,

import java.util.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the get() Method
        int value = sizes.get(Size.MEDIUM);
        System.out.println("Value of MEDIUM: " + value);
    }
}

Sortie

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Value of MEDIUM: 32

Supprimer les éléments EnumMap

remove(key) - renvoie et supprime l'entrée associée à la clé spécifiée de la carte
remove(key, value) - supprime l'entrée de la carte uniquement si la clé spécifiée correspond à la valeur spécifiée et renvoie une valeur booléenne

Par exemple,

import java.util.EnumMap;

class Main {

    enum Size {
        SMALL, MEDIUM, LARGE, EXTRALARGE
    }
    public static void main(String[] args) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the remove() Method
        int value = sizes.remove(Size.MEDIUM);
        System.out.println("Removed Value: " + value);

        boolean result = sizes.remove(Size.SMALL, 28);
        System.out.println("Is the entry {SMALL=28} removed? " + result);

        System.out.println("Updated EnumMap: " + sizes);
    }
}

Sortie

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Removed Value: 32
Is the entry {SMALL=28} removed? True
Updated EnumMap: {LARGE=36, EXTRALARGE=40}

Remplacer les é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'ancien valeur avec le nouveau valeur uniquement si l'ancien la valeur est déjà associée à la clé spécifiée
replaceAll(function) - remplace chaque valeur de la carte par 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) {

        // Creating an EnumMap of the Size enum
        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);

        // Using the replace() Method
        sizes.replace(Size.MEDIUM, 30);
        sizes.replace(Size.LARGE, 36, 34);
        System.out.println("EnumMap using replace(): " + sizes);

        // Using the replaceAll() Method
        sizes.replaceAll((key, oldValue) -> oldValue + 3);
        System.out.println("EnumMap using replaceAll(): " + sizes);
    }
}

Sortie

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

Dans le programme ci-dessus, notez la déclaration

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

Ici, la méthode accède à toutes les entrées de la carte. Il 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 du `EnumMap`
`containsKey()`	Recherche le `EnumMap` pour la clé spécifiée et renvoie un résultat booléen
`containsValue()`	Recherche le `EnumMap` pour la valeur spécifiée et renvoie un résultat booléen
`size()`	Renvoie la taille du `EnumMap`
`clear()`	Supprime toutes les entrées du `EnumMap`

EnumSet Vs. EnumMap

EnumSet et EnumMap La classe fournit des structures de données pour stocker les valeurs enum. Cependant, il existe des différences majeures entre eux.

Enum set est représenté en interne sous la forme d'une séquence de bits, tandis que la carte enum est représentée en interne sous forme de tableaux.
Enum set est créé à l'aide de ses méthodes prédéfinies comme allOf() , noneOf() , of() , etc. Cependant, une carte enum est créée à l'aide de son constructeur.

Interfaces clonables et sérialisables

Le EnumMap la classe implémente également Cloneable et Serializable interfaces.

Interface clonable

Il permet le EnumMap class pour faire une copie des instances de la classe.

Interface sérialisable

Chaque fois que des objets Java doivent être transmis sur un réseau, les objets doivent être convertis en bits ou en octets. En effet, les objets Java ne peuvent pas être transmis sur le réseau.

Le Serializable interface permet aux classes d'être sérialisées. Cela signifie des objets des classes implémentant Serializable peut être converti en bits ou en octets.

Java WeakHashMap Interface Java SortedMap

Java