Java EnumMap

Mapa de enumeración de Java

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

El EnumMap La clase del marco de colecciones de Java proporciona una implementación de mapa para los elementos de una enumeración.

En EnumMap , los elementos de enumeración se utilizan como claves . Implementa la interfaz del Mapa.

Antes de aprender sobre EnumMap , asegúrese de conocer las enumeraciones de Java.

Creación de un EnumMap

Para crear un mapa de enumeración, debemos importar el java.util.EnumMap paquete primero. Una vez que importamos el paquete, así es como podemos crear mapas de enumeración en Java.

enum Size {
    SMALL, MEDIUM, LARGE, EXTRALARGE
}

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

En el ejemplo anterior, hemos creado un mapa de enumeración llamado tamaños .

Aquí,

Tamaño - teclas de la enumeración que se asignan a valores
Entero - valores del mapa de enumeración asociado con las claves correspondientes

Métodos de EnumMap

El EnumMap La clase proporciona métodos que nos permiten realizar varios elementos en los mapas de enumeración.

Insertar elementos en EnumMap

put() - inserta la asignación de clave/valor especificada (entrada) en el mapa de enumeración
putAll() - inserta todas las entradas de un mapa específico en este mapa

Por ejemplo,

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);
    }
}

Salida

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

En el ejemplo anterior, hemos utilizado el putAll() método para insertar todos los elementos de un mapa de enumeración sizes1 a un mapa de enumeración de sizes2 .

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

Acceder a elementos de EnumMap

1. Uso de entrySet(), keySet() y valores()

entrySet() - devuelve un conjunto de todas las asignaciones de claves/valores (entrada) de un mapa de enumeración
keySet() - devuelve un conjunto de todas las claves de un mapa de enumeración
values() - devuelve un conjunto de todos los valores de un mapa de enumeración

Por ejemplo,

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());
    }
}

Salida

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. Usando el método get()

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

Por ejemplo,

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);
    }
}

Salida

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

Eliminar elementos de EnumMap

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

Por ejemplo,

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);
    }
}

Salida

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}

Reemplazar elementos de EnumMap

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

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);
    }
}

Salida

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}

En el programa anterior, observe la declaración

sizes.replaceAll((key, oldValue) -> oldValue + 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 el `EnumMap` para la clave especificada y devuelve un resultado booleano
`containsValue()`	Busca el `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. EnumMapa

Tanto el EnumSet como EnumMap La clase proporciona estructuras de datos para almacenar valores de enumeración. Sin embargo, existen algunas diferencias importantes entre ellos.

El conjunto de enumeración se representa internamente como una secuencia de bits, mientras que el mapa de enumeración se representa internamente como matrices.
El conjunto Enum se crea usando sus métodos predefinidos como allOf() , noneOf() , of() , etc. Sin embargo, un mapa de enumeración se crea usando su constructor.

Interfaces clonables y serializables

El EnumMap la clase también implementa Cloneable y Serializable interfaces.

Interfaz clonable

Permite el EnumMap class para hacer una copia de las instancias de la clase.

Interfaz serializable

Cada vez que los objetos de Java deben transmitirse a través de una red, los objetos deben convertirse en bits o bytes. Esto se debe a que los objetos Java no se pueden transmitir a través de la red.

El Serializable La interfaz permite serializar las clases. Esto significa objetos de las clases que implementan Serializable se puede convertir en bits o bytes.

Java WeakHashMap Interfaz Java SortedMap

Java