English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
En este tutorial, aprenderemos a través de ejemplos la clase Java EnumMap y sus operaciones.
La clase EnumMap del Java Collection Framework proporciona una implementación de mapeo para los elementos enumerativos.
En EnumMap, los elementos enumerativos se utilizan comoClave.Interfaz Map.
Antes de aprender EnumMap, asegúrese de comprenderJava enumeraciones.
Para crear un mapeo enumerativo, primero debemos importar el paquete java.util.EnumMap. Después de importar el paquete, podemos usar Java para crear un mapeo enumerativo.
enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE } EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);
En el ejemplo anterior, creamos un mapeo enumerativo llamado sizes.
Aquí,
Size - Mapeado al enumerativo de valoresClave
Integer- Asociados con la clave del mapeo enumerativo correspondienteValores
El clase EnumMap proporciona varios métodos que permiten realizar varias operaciones en el mapeo enumerativo.
put() - Inserte la clave especificada/Inserte los elementos de mapeo de valores (entradas) en el mapeo enumerativo
putAll() - Inserte todos los elementos del mapeo especificado en este mapeo
Por ejemplo,
import java.util.EnumMap; class Main { enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE } public static void main(String[] args) { //Cree un EnumMap para el enumerativo size EnumMap<Size, Integer> sizes1 = new EnumMap<>(Size.class); // Utilice el método put() sizes1.put(Size.SMALL, 28); sizes1.put(Size.MEDIUM, 32); System.out.println("EnumMap1: "{ + sizes1); EnumMap<Size, Integer> sizes2 = new EnumMap<>(Size.class); // Utilice el método putAll() sizes2.putAll(sizes1); sizes2.put(Size.LARGE, 36); System.out.println("EnumMap2: "{ + sizes2); } }
Resultados de salida
EnumMap1: {SMALL=28, MEDIUM=32} EnumMap2: {SMALL=28, MEDIUM=32, LARGE=36}
En el ejemplo anterior, usamos el método putAll() para insertar el mapeo enumerativo size1de todos los elementos en size2del mapeo enumerativo.
También se puede usar putAll() para insertar elementos de otros mapeos (como HashMap, TreeMap, etc.) en el mapeo enumerativo. Sin embargo, todos los mapeos deben tener el mismo tipo de enumeración.
1Utilice entrySet(), keySet() y values()
entrySet() - Devuelve todas las claves del mapeo enumerativo/La colección de elementos de mapeo de valores (entradas)
keySet() - Devuelve la colección de todas las claves del mapeo enumerativo
values() - Devuelve la colección de todos los valores del mapeo de enumeraciones
Por ejemplo,
import java.util.EnumMap; class Main { enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE } public static void main(String[] args) { // Crear EnumMap para el enumerado 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); // Usar el método entrySet() System.out.println("Clave/Mapeo de valores: + sizes.entrySet()); // Usar el método keySet() System.out.println("Claves: ", + sizes.keySet()); // Usar el método values() System.out.println("Valores: ", + sizes.values()); } }
Resultados de salida
EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} Clave/Mapeo de valores: [SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40] Claves: [SMALL, MEDIUM, LARGE, EXTRALARGE] Valores: [28, 32, 36, 40]
2.Usar el método get()
El método get() devuelve el valor asociado con la clave especificada. Si no se encuentra la clave especificada, devuelve null.
Por ejemplo,
import java.util.EnumMap; class Main { enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE } public static void main(String[] args) { // Crear EnumMap para el enumerado 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); // Usar el método get() int value = sizes.get(Size.MEDIUM); System.out.println("Valor de MEDIUM: ", + value); } }
Resultados de salida
EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} Valor de MEDIUM: 32
remove(key) - Devuelve y elimina la entrada asociada con la clave especificada del mapeo
remove(key, value) - Elimina la entrada del mapeo solo si la clave especificada está mapeada 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) { // Crear EnumMap para el enumerado 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); // Usar el método remove() int value = sizes.remove(Size.MEDIUM); System.out.println("Valor eliminado: ", + value); boolean result = sizes.remove(Size.SMALL, 28); System.out.println("Entrada {SMALL=",28} ¿Eliminado? \ + result); System.out.println("EnumMap actualizado: ", + sizes); } }
Resultados de salida
EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} Eliminar valor: 32 Entrada {SMALL=28} ¿Eliminado? True EnumMap actualizado: {LARGE=36, EXTRALARGE=40}
replace(key, value) - Reemplazar el valor asociado con la clave key por value
replace(key, old, new) - Sólo se reemplaza el valor old con el nuevo valor new cuando el valor old ya está asociado con la clave key específica
replaceAll(function) - Reemplazar cada valor mapeado con el resultado de una función específica
import java.util.EnumMap; class Main { enum Size { SMALL, MEDIUM, LARGE, EXTRALARGE } public static void main(String[] args) { // Crear EnumMap para el enumerado 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); // Uso del método replace() sizes.replace(Size.MEDIUM, 30); sizes.replace(Size.LARGE, 36, 34); System.out.println("EnumMap: Uso del método replace(): " + sizes); // Uso del método replaceAll() sizes.replaceAll((key, oldValue) -> oldValue + 3); System.out.println("EnumMap: Uso del método replaceAll(): " + sizes); } }
Resultados de salida
EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40} EnumMap: Uso del método replace(): {SMALL=28, MEDIUM=30, LARGE=34, EXTRALARGE=40} EnumMap: Uso del método replaceAll(): {SMALL=31, MEDIUM=33, LARGE=37, EXTRALARGE=43}
En el programa anterior, preste atención a las siguientes declaraciones
sizes.replaceAll((key, oldValue) -> oldValue + 3);
Aquí, este método accede a todos los elementos del mapa. Luego, reemplaza todos los valores porExpresiones lambdaNuevos valores proporcionados.
Métodos | Descripción |
---|---|
clone() | Crear una copia de EnumMap |
containsKey() | Buscar la clave especificada por EnumMap y devolver el resultado booleano |
containsValue() | Buscar el valor especificado por EnumMap en la búsqueda y devolver el resultado booleano |
size() | Tamaño devuelto de EnumMap |
clear() | Eliminar todos los elementos de EnumMap |
EnumSetY la clase EnumMap proporcionan estructuras de datos para almacenar valores de enumeración. Sin embargo, existen algunas diferencias principales entre ellos.
Los conjuntos de enumeraciones se representan internamente en forma de secuencia de bits, mientras que los mapeos de enumeraciones se representan internamente en forma de array.
Los conjuntos de enumeraciones se crean utilizando métodos predefinidos, como allOf(), noneOf(), of(), etc. Sin embargo, el mapeo de enumeraciones se crea utilizando su constructor.
La clase EnumMap también implementa las interfaces Cloneable y Serializable.
Cloneable ClonarInterfaz
Permite que la clase EnumMap copie instancias de la clase.
Interfaz serializable
Cada vez que se necesite transmitir un objeto Java a través de la red, se debe convertir el objeto en bits o bytes. Esto se debe a que los objetos Java no pueden transmitirse a través de la red.
La interfaz Serializable permite que la clase pueda ser serializada. Esto significa que Serializable puede convertir los objetos de la clase implementada en bits o bytes.