Clase EnumMap en Java

EnumMap es una implementación especializada de la interfaz Map para tipos de enumeración . Extiende AbstractMap e implementa la interfaz Map en Java. Pertenece al paquete java.util . Algunas características importantes de EnumMap son las siguientes: 

• La clase EnumMap es miembro de Java Collections Framework y no está sincronizada.
• EnumMap es una colección ordenada y se mantienen en el orden natural de sus claves (el orden natural de las claves significa el orden en el que se declaran las constantes de enumeración dentro del tipo de enumeración)
• Es una implementación de mapas de alto rendimiento, mucho más rápida que HashMap .
• Todas las claves de cada instancia de EnumMap deben ser claves de un solo tipo de enumeración .
• EnumMap no permite la clave nula y lanza NullPointerException cuando intentamos insertar la clave nula.
• Los iteradores devueltos por las vistas de colección son débilmente consistentes: nunca lanzarán ConcurrentModificationException y pueden o no mostrar los efectos de cualquier modificación al mapa que ocurra mientras la iteración está en progreso.
• EnumMap se representa internamente como arrays. Esta representación es extremadamente compacta y eficiente.

Sintaxis: Declaración

public class EnumMap<K extends Enum<K>,​V> extends AbstractMap<K,​V> implements Serializable, Cloneable

Parámetros:

• Tipo de objeto clave
• Tipo de objeto de valor

K debe extender Enum , lo que impone el requisito de que las claves deben ser del tipo de enumeración especificado . 

Jerarquía de EnumMap 

 Constructores de EnumMap 

1. EnumMap (Class keyType): el constructor se usa para crear un EnumMap vacío con el keyType especificado .
2. EnumMap (EnumMap m): el constructor se usa para crear un mapa de enumeración con el mismo tipo de clave que el mapa de enumeración especificado, con asignaciones iniciales iguales a EnumMap
3. EnumMap (mapa m): el constructor se usa para crear un mapa de enumeración con la inicialización del mapa especificado en el parámetro.

Ejemplo  

// Java Program to illustrate Working of EnumMap class
// and its functions
 
// Importing EnumMap class
import java.util.EnumMap;
 
// Main class
public class EnumMapExample {
 
    // Enum
    public enum GFG {
        CODE,
        CONTRIBUTE,
        QUIZ,
        MCQ;
    }
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Java EnumMap
        // Creating an empty EnumMap with key
        // as enum type state
        EnumMap<GFG, String> gfgMap
            = new EnumMap<GFG, String>(GFG.class);
 
        // Putting values inside EnumMap in Java
        // Inserting Enum keys different from
        // their natural order
        gfgMap.put(GFG.CODE, "Start Coding with gfg");
        gfgMap.put(GFG.CONTRIBUTE, "Contribute for others");
        gfgMap.put(GFG.QUIZ, "Practice Quizes");
        gfgMap.put(GFG.MCQ, "Test Speed with Mcqs");
 
        // Printing size of EnumMap
        System.out.println("Size of EnumMap in java: "
                           + gfgMap.size());
 
        // Printing Java EnumMap
        // Print EnumMap in natural order
        // of enum keys (order on which they are declared)
        System.out.println("EnumMap: " + gfgMap);
 
        // Retrieving value from EnumMap
        System.out.println("Key : " + GFG.CODE + " Value: "
                           + gfgMap.get(GFG.CODE));
 
        // Checking if EnumMap contains a particular key
        System.out.println(
            "Does gfgMap has " + GFG.CONTRIBUTE + ": "
            + gfgMap.containsKey(GFG.CONTRIBUTE));
 
        // Checking if EnumMap contains a particular value
        System.out.println(
            "Does gfgMap has :" + GFG.QUIZ + " : "
            + gfgMap.containsValue("Practice Quizes"));
        System.out.println("Does gfgMap has :" + GFG.QUIZ
                           + " : "
                           + gfgMap.containsValue(null));
    }
}

Size of EnumMap in java: 4
EnumMap: {CODE=Start Coding with gfg, CONTRIBUTE=Contribute for others, QUIZ=Practice Quizes, MCQ=Test Speed with Mcqs}
Key : CODE Value: Start Coding with gfg
Does gfgMap has CONTRIBUTE: true
Does gfgMap has :QUIZ : true
Does gfgMap has :QUIZ : false

Operaciones básicas en EnumMap

Operación 1: Adición de elementos

Para agregar elementos a EnumMap, podemos usar el método put() o putAll() como se muestra a continuación.

// Java Program to Add Elements to the EnumMap
 
// Importing EnumMap class
import java.util.EnumMap;
 
// Main class
// AddingElementsToEnumMap
class GFG {
 
    enum Color { RED, GREEN, BLUE, WHITE }
    public static void main(String[] args)
    {
 
        // Creating an EnumMap of the Color enum
        EnumMap<Color, Integer> colors1
            = new EnumMap<>(Color.class);
 
        // Insert elements in Map
        // using put() method
        colors1.put(Color.RED, 1);
        colors1.put(Color.GREEN, 2);
 
        // Printing mappings to the console
        System.out.println("EnumMap colors1: " + colors1);
 
        // Creating an EnumMap of the Color Enum
        EnumMap<Color, Integer> colors2
            = new EnumMap<>(Color.class);
 
        // Adding elements using the putAll() method
        colors2.putAll(colors1);
        colors2.put(Color.BLUE, 3);
 
        // Printing mappings to the console
        System.out.println("EnumMap colors2: " + colors2);
    }
}

EnumMap colors1: {RED=1, GREEN=2}
EnumMap colors2: {RED=1, GREEN=2, BLUE=3}

 Operación 2: Acceso a los Elementos

Podemos acceder a los elementos de EnumMap usando entrySet(), keySet(), values(), get(). El siguiente ejemplo explica estos métodos.

// Java Program to Access the Elements of EnumMap
 
// Importing required classes
import java.util.EnumMap;
 
// Main class
// AccessElementsOfEnumMap
class GFG {
 
    // Enum
    enum Color { RED, GREEN, BLUE, WHITE }
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an EnumMap of the Color enum
        EnumMap<Color, Integer> colors
            = new EnumMap<>(Color.class);
 
        // Inserting elements using put() method
        colors.put(Color.RED, 1);
        colors.put(Color.GREEN, 2);
        colors.put(Color.BLUE, 3);
        colors.put(Color.WHITE, 4);
 
        System.out.println("EnumMap colors : " + colors);
 
        // Using the entrySet() method
        System.out.println("Key/Value mappings: "
                           + colors.entrySet());
 
        // Using the keySet() method
        System.out.println("Keys: " + colors.keySet());
 
        // Using the values() method
        System.out.println("Values: " + colors.values());
 
        // Using the get() method
        System.out.println("Value of RED : "
                           + colors.get(Color.RED));
    }
}

EnumMap colors : {RED=1, GREEN=2, BLUE=3, WHITE=4}
Key/Value mappings: [RED=1, GREEN=2, BLUE=3, WHITE=4]
Keys: [RED, GREEN, BLUE, WHITE]
Values: [1, 2, 3, 4]
Value of RED : 1

Operación 3: Eliminación de elementos

Para eliminar los elementos, EnumMap proporciona dos variaciones del método remove().

Ejemplo

// Java program to Remove Elements of EnumMap
 
// Importing EnumMap class
import java.util.EnumMap;
 
// Main class
class GFG {
 
    // Enum
    enum Color {
 
        // Custom elements
        RED,
        GREEN,
        BLUE,
        WHITE
    }
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an EnumMap of the Color enum
        EnumMap<Color, Integer> colors
            = new EnumMap<>(Color.class);
 
        // Inserting elements in the Map
        // using put() method
        colors.put(Color.RED, 1);
        colors.put(Color.GREEN, 2);
        colors.put(Color.BLUE, 3);
        colors.put(Color.WHITE, 4);
 
        // Printing colors in the EnumMap
        System.out.println("EnumMap colors : " + colors);
 
        // Removing a mapping
        // using remove() Method
        int value = colors.remove(Color.WHITE);
 
        // Displaying the removed value
        System.out.println("Removed Value: " + value);
 
        // Removing specific color and storing boolean
        // if removed or not
        boolean result = colors.remove(Color.RED, 1);
 
        // Printing the boolean result whether removed or
        // not
        System.out.println("Is the entry {RED=1} removed? "
                           + result);
 
        // Printing the updated Map to the console
        System.out.println("Updated EnumMap: " + colors);
    }
}

EnumMap colors : {RED=1, GREEN=2, BLUE=3, WHITE=4}
Removed Value: 4
Is the entry {RED=1} removed? true
Updated EnumMap: {GREEN=2, BLUE=3}

Operación 4: Sustitución de elementos

La interfaz de mapa proporciona tres variaciones del método replace() para cambiar las asignaciones de EnumMap.

Ejemplo

// Java Program to Replace Elements of EnumMap
 
// Importing required classes
import java.util.EnumMap;
 
// Main class
class GFG {
 
    // Enum
    enum Color {
 
        RED,
        GREEN,
        BLUE,
        WHITE
    }
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an EnumMap of the Color enum
        EnumMap<Color, Integer> colors
            = new EnumMap<>(Color.class);
 
        // Inserting elements to Map
        // using put() method
        colors.put(Color.RED, 1);
        colors.put(Color.GREEN, 2);
        colors.put(Color.BLUE, 3);
        colors.put(Color.WHITE, 4);
 
        // Printing all elements inside above Map
        System.out.println("EnumMap colors " + colors);
 
        // Replacing certain elements depicting colors
        // using the replace() method
        colors.replace(Color.RED, 11);
        colors.replace(Color.GREEN, 2, 12);
 
        // Printing the updated elements (colors)
        System.out.println("EnumMap using replace(): "
                           + colors);
 
        // Replacing all colors using the replaceAll()
        // method
        colors.replaceAll((key, oldValue) -> oldValue + 3);
 
        // Printing the elements of above Map
        System.out.println("EnumMap using replaceAll(): "
                           + colors);
    }
}

EnumMap colors {RED=1, GREEN=2, BLUE=3, WHITE=4}
EnumMap using replace(): {RED=11, GREEN=12, BLUE=3, WHITE=4}
EnumMap using replaceAll(): {RED=14, GREEN=15, BLUE=6, WHITE=7}

EnumMap sincronizado

La implementación de un EnumMap no está sincronizada. Esto significa que si varios subprocesos acceden a un conjunto de árboles al mismo tiempo y al menos uno de los subprocesos modifica el conjunto, debe sincronizarse externamente. Esto normalmente se logra usando el métodosynchronedMap() de la clase Collections . Es mejor hacerlo en el momento de la creación, para evitar el acceso no sincronizado accidental. 

 Map<EnumKey, V> m = Collections.synchronizedMap(new EnumMap<EnumKey, V>(...));

Métodos de EnumMap

• K – Tipo del objeto clave
• V – Tipo del objeto de valor

Métodos declarados en la clase AbstractMap

Métodos declarados en la interfaz java.util.Map

EnumMap frente a EnumSet

Este artículo es una contribución de Pratik Agarwal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeek y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.