Dominando Java EnumMap: Mapeo Clave-Valor Eficiente con Enums

Java EnumMap

En este tutorial, aprenderemos sobre la clase EnumMap de Java y sus operaciones con la ayuda de ejemplos.

La clase EnumMap del framework de colecciones de Java proporciona una implementación de mapa para elementos de un enum.

En EnumMap, los elementos del enum se usan como claves. Implementa la interfaz Map.

Antes de aprender sobre EnumMap, asegúrate de conocer los Enums de Java.

Creando un EnumMap

Para crear un enum map, primero debemos importar el paquete java.util.EnumMap. Una vez importado, así es como podemos crear enum maps en Java.

enum Tamanio { PEQUENO, MEDIANO, GRANDE, EXTRAGRANDE }
EnumMap<Tamanio, Integer> tamanios = new EnumMap<>(Tamanio.class);

En el ejemplo anterior, hemos creado un enum map llamado tamanios.

Aquí,

Tamanio - claves del enum que mapean a valores
Integer - valores del enum map asociados con las claves correspondientes

Métodos de EnumMap

La clase EnumMap proporciona métodos que nos permiten realizar varias operaciones en los enum maps.

Insertar Elementos en EnumMap

put() - inserta el mapeo clave/valor (entrada) especificado en el enum map
putAll() - inserta todas las entradas de un mapa especificado en este mapa

Por ejemplo,

import java.util.EnumMap;
class Main {
    enum Tamanio { PEQUENO, MEDIANO, GRANDE, EXTRAGRANDE }
    public static void main(String[] args) {
        // Creando un EnumMap del enum Tamanio
        EnumMap<Tamanio, Integer> tamanios1 = new EnumMap<>(Tamanio.class);
        // Usando el método put()
        tamanios1.put(Tamanio.PEQUENO, 28);
        tamanios1.put(Tamanio.MEDIANO, 32);
        System.out.println("EnumMap1: " + tamanios1);
        EnumMap<Tamanio, Integer> tamanios2 = new EnumMap<>(Tamanio.class);
        // Usando el método putAll()
        tamanios2.putAll(tamanios1);
        tamanios2.put(Tamanio.GRANDE, 36);
        System.out.println("EnumMap2: " + tamanios2);
    }
}

Salida

EnumMap1: {PEQUENO=28, MEDIANO=32} EnumMap2: {PEQUENO=28, MEDIANO=32, GRANDE=36}

En el ejemplo anterior, hemos usado el método putAll() para insertar todos los elementos de un enum map tamanios1 a un enum map de tamanios2.

También es posible insertar elementos desde otros mapas como HashMap, TreeMap, etc. a un enum map usando putAll(). Sin embargo, todos los mapas deben ser del mismo tipo de enum.

Acceder a Elementos de EnumMap

1. Usando entrySet(), keySet() y values()

entrySet() - devuelve un conjunto de todos los mapeos clave/valor (entrada) de un enum map
keySet() - devuelve un conjunto de todas las claves de un enum map
values() - devuelve un conjunto de todos los valores de un enum map

Por ejemplo,

import java.util.EnumMap;
class Main {
    enum Tamanio { PEQUENO, MEDIANO, GRANDE, EXTRAGRANDE }
    public static void main(String[] args) {
        // Creando un EnumMap del enum Tamanio
        EnumMap<Tamanio, Integer> tamanios = new EnumMap<>(Tamanio.class);
        tamanios.put(Tamanio.PEQUENO, 28);
        tamanios.put(Tamanio.MEDIANO, 32);
        tamanios.put(Tamanio.GRANDE, 36);
        tamanios.put(Tamanio.EXTRAGRANDE, 40);
        System.out.println("EnumMap: " + tamanios);
        // Usando entrySet()
        System.out.println("Mapeos Clave/Valor: " + tamanios.entrySet());
        // Usando keySet()
        System.out.println("Claves: " + tamanios.keySet());
        // Usando values()
        System.out.println("Valores: " + tamanios.values());
    }
}

Salida

EnumMap: {PEQUENO=28, MEDIANO=32, GRANDE=36, EXTRAGRANDE=40} Mapeos Clave/Valor: [PEQUENO=28, MEDIANO=32, GRANDE=36, EXTRAGRANDE=40] Claves: [PEQUENO, MEDIANO, GRANDE, EXTRAGRANDE] Valores: [28, 32, 36, 40]

2. Usando el Método get()

El método get() devuelve el valor asociado con la clave especificada. Devuelve null si la clave especificada no se encuentra.

Por ejemplo,

import java.util.EnumMap;
class Main {
    enum Tamanio { PEQUENO, MEDIANO, GRANDE, EXTRAGRANDE }
    public static void main(String[] args) {
        // Creando un EnumMap del enum Tamanio
        EnumMap<Tamanio, Integer> tamanios = new EnumMap<>(Tamanio.class);
        tamanios.put(Tamanio.PEQUENO, 28);
        tamanios.put(Tamanio.MEDIANO, 32);
        tamanios.put(Tamanio.GRANDE, 36);
        tamanios.put(Tamanio.EXTRAGRANDE, 40);
        System.out.println("EnumMap: " + tamanios);
        // Usando get()
        int valor = tamanios.get(Tamanio.MEDIANO);
        System.out.println("Valor de MEDIANO: " + valor);
    }
}

Salida

EnumMap: {PEQUENO=28, MEDIANO=32, GRANDE=36, EXTRAGRANDE=40} Valor de MEDIANO: 32

Eliminar Elementos de EnumMap

remove(clave) - devuelve y elimina la entrada asociada con la clave especificada del mapa
remove(clave, valor) - elimina la entrada del mapa solo si la clave especificada mapeaba al valor especificado y devuelve un valor booleano

Por ejemplo,

import java.util.EnumMap;
class Main {
    enum Tamanio { PEQUENO, MEDIANO, GRANDE, EXTRAGRANDE }
    public static void main(String[] args) {
        // Creando un EnumMap del enum Tamanio
        EnumMap<Tamanio, Integer> tamanios = new EnumMap<>(Tamanio.class);
        tamanios.put(Tamanio.PEQUENO, 28);
        tamanios.put(Tamanio.MEDIANO, 32);
        tamanios.put(Tamanio.GRANDE, 36);
        tamanios.put(Tamanio.EXTRAGRANDE, 40);
        System.out.println("EnumMap: " + tamanios);
        // Usando remove()
        int valor = tamanios.remove(Tamanio.MEDIANO);
        System.out.println("Valor Eliminado: " + valor);
        boolean resultado = tamanios.remove(Tamanio.PEQUENO, 28);
        System.out.println("¿Se eliminó la entrada {PEQUENO=28}? " + resultado);
        System.out.println("EnumMap Actualizado: " + tamanios);
    }
}

Salida

EnumMap: {PEQUENO=28, MEDIANO=32, GRANDE=36, EXTRAGRANDE=40} Valor Eliminado: 32 ¿Se eliminó la entrada {PEQUENO=28}? true EnumMap Actualizado: {GRANDE=36, EXTRAGRANDE=40}

Reemplazar Elementos de EnumMap

replace(clave, valor) - reemplaza el valor asociado con la clave especificada por el nuevo valor
replace(clave, antiguo, nuevo) - reemplaza el valor antiguo con el nuevo solo si el valor antiguo ya está asociado con la clave especificada
replaceAll(función) - reemplaza cada valor del mapa con el resultado de la función especificada

import java.util.EnumMap;
class Main {
    enum Tamanio { PEQUENO, MEDIANO, GRANDE, EXTRAGRANDE }
    public static void main(String[] args) {
        // Creando un EnumMap del enum Tamanio
        EnumMap<Tamanio, Integer> tamanios = new EnumMap<>(Tamanio.class);
        tamanios.put(Tamanio.PEQUENO, 28);
        tamanios.put(Tamanio.MEDIANO, 32);
        tamanios.put(Tamanio.GRANDE, 36);
        tamanios.put(Tamanio.EXTRAGRANDE, 40);
        System.out.println("EnumMap: " + tamanios);
        // Usando replace()
        tamanios.replace(Tamanio.MEDIANO, 30);
        tamanios.replace(Tamanio.GRANDE, 36, 34);
        System.out.println("EnumMap usando replace(): " + tamanios);
        // Usando replaceAll()
        tamanios.replaceAll((clave, valorAntiguo) -> valorAntiguo + 3);
        System.out.println("EnumMap usando replaceAll(): " + tamanios);
    }
}

Salida

EnumMap: {PEQUENO=28, MEDIANO=32, GRANDE=36, EXTRAGRANDE=40} EnumMap usando replace(): {PEQUENO=28, MEDIANO=30, GRANDE=34, EXTRAGRANDE=40} EnumMap usando replaceAll(): {PEQUENO=31, MEDIANO=33, GRANDE=37, EXTRAGRANDE=43}

En el programa anterior, observa la sentencia

tamanios.replaceAll((clave, valorAntiguo) -> valorAntiguo + 3);

Aquí, el método accede a todas las entradas del mapa. Luego reemplaza todos los valores con los nuevos valores proporcionados por las expresiones lambda.

Otros Métodos

Método	Descripción
`clone()`	Crea una copia del `EnumMap`
`containsKey()`	Busca la `EnumMap` para la clave especificada y devuelve un resultado booleano
`containsValue()`	Busca la `EnumMap` para el valor especificado y devuelve un resultado booleano
`size()`	Devuelve el tamaño del `EnumMap`
`clear()`	Elimina todas las entradas del `EnumMap`

EnumSet Vs. EnumMap

Tanto la clase EnumSet como EnumMap proporcionan estructuras de datos para almacenar valores de enum. Sin embargo, existen algunas diferencias mayores entre ellos.

Enum set se representa internamente como una secuencia de bits, mientras que el enum map se representa internamente como arrays.
Enum set se crea usando sus métodos predefinidos como allOf(), noneOf(), of(), etc. Sin embargo, un enum map se crea usando su constructor.

Interfaces Cloneable y Serializable

La clase EnumMap también implementa las interfaces Cloneable y Serializable.

Interfaz Cloneable

Permite a la clase EnumMap hacer una copia de instancias de la clase.

Interfaz Serializable

Cada vez que los objetos Java necesitan ser transmitidos por una red, los objetos necesitan convertirse en bits o bytes. Esto es porque los objetos Java no pueden ser transmitidos por la red.

La interfaz Serializable permite que las clases sean serializadas. Esto significa que los objetos de las clases que implementan Serializable pueden convertirse en bits o bytes.

Java WeakHashMap: Entendimiento, Uso y Diferencias Clave Interfaz SortedMap de Java: Visión General, Métodos e Implementación con TreeMap

Java