English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriales básicos de Java

control de flujo Java

Java array

Java orientado a objetos (I)

Java orientado a objetos (II)

Java orientado a objetos (III)

Manejo de excepciones en Java

Java Lista (List)

Java Cola (Queue)

Java Conjunto Map

Java Conjunto Set

Java Entrada/Salida (I/)

Lector Java/Escritor

Otras temáticas de Java

Java EnumMap

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.

Crear un EnumMap

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

Métodos del EnumMap

El clase EnumMap proporciona varios métodos que permiten realizar varias operaciones en el mapeo enumerativo.

Inserte el elemento en EnumMap

  • 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.

Acceder a los elementos de EnumMap

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

Eliminar elementos de EnumMap

  • 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}

Reemplazar elementos de EnumMap

  • 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.

Otros métodos

MétodosDescripció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

La diferencia entre EnumSet y 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.

Interfaz de Cloneable y Serializable

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.