Java EnumMap

In this tutorial, we will learn about the Java EnumMap class and its operations with the help of examples.

The EnumMap class of the Java collection framework provides a mapping implementation for enumeration elements.

In EnumMap, enumeration elements are used asKey. It implementsMap interface.

Before learning EnumMap, make sure you understandEnumerazione Java.

Create an EnumMap

To create an enumeration map, we must first import the java.util.EnumMap package. After importing the package, we can use Java to create an enumeration map.

enum Size {
　　　　PICCOLO, MEDIO, GRANDE, ECCEZIONALE
}
EnumMap<Size, Integer> sizes = new EnumMap<>(Size.class);

In the above example, we created an enumeration map named sizes.

Here,

• Size - The enumeration mapped to the valueKey

• Integer - The enumeration map associated with the corresponding keyValue

Methods of EnumMap

The EnumMap class provides some methods that allow us to perform various elements on enumeration maps.

Insert an element into EnumMap

• put() - Insert the specified key/value mapping (entry) into the enumeration map

• putAll() - Insert all entries of the specified map into this map

Ad esempio:

import java.util.EnumMap;
class Main {
　　　　enum Size {
　　　　　　　　PICCOLO, MEDIO, GRANDE, ECCEZIONALE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　// Creazione di un EnumMap per l'enumerazione size
　　　　　　　　EnumMap<Size, Integer> sizes1 = new EnumMap<>(Size.class);
　　　　　　　　// Utilizzo del metodo put()
　　　　　　　　sizes1.put(Size.PICCOLO, 28);
　　　　　　　　sizes1.put(Size.MEDIO, 32);
　　　　　　　　System.out.println("EnumMap1: " + sizes1);
　　　　　　　　EnumMap<Size, Integer> sizes2 = new EnumMap<>(Size.class);
　　　　　　　　// Utilizzo del metodo putAll()
　　　　　　　　sizes2.putAll(sizes1);
　　　　　　　　sizes2.put(Size.GRANDE, 36);
　　　　　　　　System.out.println("EnumMap2: " + sizes2);
　　　　}
}

Risultato di output

EnumMap1: {PICCOLO=28, MEDIO=32}
EnumMap2: {PICCOLO=28, MEDIO=32, GRANDE=36}

Nell'esempio sopra, utilizziamo il metodo putAll() per inserire tutti gli elementi della mappatura enumerativa size1 nella mappatura enumerativa size2.

Puoi anche utilizzare putAll() per inserire gli elementi di altri mapping (come HashMap, TreeMap, ecc.) nell'enumerazione della mappatura. Tuttavia, tutti i mapping devono avere lo stesso tipo di enumerazione.

Accesso agli elementi di EnumMap

1. Utilizzo di entrySet(), keySet() e values()

• entrySet() - Restituisce l'insieme di tutte le mappature chiave/valore (entità) della mappatura enumerativa

• keySet() - Restituisce l'insieme di tutte le chiavi della mappatura enumerativa

• values() - Restituisce l'insieme di tutti i valori della mappatura enumerativa

Ad esempio:

import java.util.EnumMap;
class Main {
　　　　enum Size {
　　　　　　　　PICCOLO, MEDIO, GRANDE, ECCEZIONALE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　// Creazione di EnumMap per l'enumerazione 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);
　　　　　　　　// Utilizzo del metodo entrySet()
　　　　　　　　System.out.println("Mappatura Chiave/Valore: " + sizes.entrySet());
　　　　　　　　// Utilizzo del metodo keySet()
　　　　　　　　System.out.println("Chiavi: " + sizes.keySet());
　　　　　　　　// Utilizzo del metodo values()
　　　　　　　　System.out.println("Valori: " + sizes.values());
　　　　}
}

Risultato di output

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Mappatura Chiave/Valore: [PICCOLO=28, MEDIO=32, GRANDE=36, ESTREMAMENTE GRANDE=40]
Chiavi: [PICCOLO, MEDIO, GRANDE, ECCEZIONALE]
Valori: [28, 32, 36, 40]

2. Utilizzo del metodo get()

Il metodo get() restituisce il valore associato alla chiave specificata. Se non viene trovata la chiave specificata, viene restituito null.

Ad esempio:

import java.util.EnumMap;
class Main {
　　　　enum Size {
　　　　　　　　PICCOLO, MEDIO, GRANDE, ECCEZIONALE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　// Creazione di EnumMap per l'enumerazione 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);
　　　　　　　　// Utilizzo del metodo get()
　　　　　　　　int value = sizes.get(Size.MEDIO);
　　　　　　　　System.out.println("Valore di MEDIO: " + value);
　　　　}
}

Risultato di output

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Valore di MEDIO: 32

Elimina l'elemento EnumMap

• remove(key) - Restituisce e elimina la voce associata alla chiave specificata

• remove(key, value) - Elimina la voce dalla mappatura solo se la chiave specificata è mappata al valore specificato e restituisce un valore booleano

Ad esempio:

import java.util.EnumMap;
class Main {
　　　　enum Size {
　　　　　　　　PICCOLO, MEDIO, GRANDE, ECCEZIONALE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　// Creazione di EnumMap per l'enumerazione 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);
　　　　　　　　// Utilizzo del metodo remove()
　　　　　　　　int value = sizes.remove(Size.MEDIO);
　　　　　　　　System.out.println("Valore eliminato: " + value);
　　　　　　　　boolean result = sizes.remove(Size.PICCOLO, 28);
　　　　　　　　System.out.println("L'entrata {PICCOLO=28} è stata eliminata? " + result);
　　　　　　　　System.out.println("EnumMap aggiornato: " + sizes);
　　　　}
}

Risultato di output

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Valore eliminato: 32
L'entrata {PICCOLO=28} è stata eliminata? True
EnumMap aggiornato: {GRANDE=36, ECCEZIONALE=40}

Sostituisci l'elemento EnumMap

• replace(key, value) - Sostituisci il valore associato alla chiave key con value

• replace(key, old, new) - Sostituisci il valore old con new solo se il valore old è associato al chiave specificata key

• replaceAll(function) - Sostituisci ogni valore della mappatura con il risultato della funzione specificata

import java.util.EnumMap;
class Main {
　　　　enum Size {
　　　　　　　　PICCOLO, MEDIO, GRANDE, ECCEZIONALE
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　// Creazione di EnumMap per l'enumerazione 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);
　　　　　　　　// Utilizzo del metodo replace()
　　　　　　　　sizes.replace(Size.MEDIUM, 30);
　　　　　　　　sizes.replace(Size.LARGE, 36, 34);
　　　　　　　　System.out.println("Utilizzo EnumMap di replace(): " + sizes);
　　　　　　　　// Utilizzo del metodo replaceAll()
　　　　　　　　sizes.replaceAll((key, oldValue) -> oldValue + 3);
　　　　　　　　System.out.println("Utilizzo EnumMap di replaceAll(): " + sizes);
　　　　}
}

Risultato di output

EnumMap: {SMALL=28, MEDIUM=32, LARGE=36, EXTRALARGE=40}
Utilizzo EnumMap di replace(): {SMALL=28, MEDIUM=30, LARGE=34, EXTRALARGE=40}
Utilizzo EnumMap di replaceAll(): {SMALL=31, MEDIUM=33, LARGE=37, EXTRALARGE=43}

Nell'esempio sopra, notare le seguenti istruzioni

sizes.replaceAll((key, oldValue) -> oldValue + 3);

In questo caso, il metodo accede a tutti gli elementi della mappa. Poi, sostituisce tutti i valori conEspressioni lambdaNuovi valori forniti.

Altri metodi

Differenza tra EnumSet e EnumMap

EnumSetE la classe EnumMap forniscono la struttura dati per memorizzare i valori enumerati. Tuttavia, esistono alcune principali differenze tra loro.

• Le collezioni Enum sono rappresentate internamente come sequenze di bit, mentre le mappature Enum sono rappresentate internamente come array.

• Le collezioni Enum sono create utilizzando metodi predefiniti come allOf(), noneOf(), of() ecc. Tuttavia, le mappature Enum sono create utilizzando il costruttore.

Interfaccia Cloneable e Serializable

La classe EnumMap implementa anche le interfacce Cloneable e Serializable.

Cloneable ClonazioneInterfaccia

Permette di copiare l'istanza della classe EnumMap.

Interfaccia serializzabile

Ogni volta che è necessario trasmettere un oggetto Java attraverso una rete, è necessario convertire l'oggetto in bit o byte. Questo perché gli oggetti Java non possono essere trasportati attraverso una rete.

L'interfaccia Serializable permette a una classe di essere serializzata. Questo significa che Serializable può convertire gli oggetti delle classi implementate in bit o byte.