Java EnumMap

Dans ce tutoriel, nous allons apprendre à utiliser la classe Java EnumMap et ses opérations à l'aide d'exemples.

La classe EnumMap du Java Collection Framework fournit une implémentation de mapping pour les éléments d'énumération.

Dans EnumMap, les éléments d'énumération sont utilisés commeClé.L'interface Map.

Avant d'étudier EnumMap, assurez-vous de comprendreJava enumeration.

Créez une EnumMap

Pour créer une cartographie d'énumération, nous devons d'abord importer le paquet java.util.EnumMap. Après avoir importé le paquet, vous pouvez utiliser Java pour créer une cartographie d'énumération.

enum　Size　{
　　　　SMALL,　MEDIUM,　LARGE,　EXTRALARGE
}
EnumMap<Size,　Integer>　sizes　=　new　EnumMap<>(Size.class);

Dans l'exemple précédent, nous avons créé une cartographie d'énumération nommée sizes.

Ici,

• Size - Enum de la cartographie correspondante inséré dans la valeurClé

• Integer- Associées à la cartographie d'énumération correspondante duLes valeurs

Les méthodes de EnumMap

La classe EnumMap fournit plusieurs méthodes permettant d'exécuter divers éléments sur la cartographie d'énumération.

Insérez l'élément dans EnumMap

• put() - Insérez la clé spécifiée/Insérez les éléments de la cartographie de valeurs (entrée) dans la cartographie d'énumération

• putAll() - Insérez tous les éléments de la cartographie spécifiée dans cette cartographie

Par exemple,

import　java.util.EnumMap;
class　Main　{
　　　　enum　Size　{
　　　　　　　　SMALL,　MEDIUM,　LARGE,　EXTRALARGE
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Créez une EnumMap pour l'énumération size
　　　　　　　　EnumMap<Size, Integer> sizes1　= new EnumMap<>(Size.class);
　　　　　　　　//　Utilisez la méthode put()
　　　　　　　　sizes1.put(Size.SMALL,　28);
　　　　　　　　sizes1.put(Size.MEDIUM,　32);
　　　　　　　　System.out.println("EnumMap1: "　+　sizes1);
　　　　　　　　EnumMap<Size, Integer> sizes2　= new EnumMap<>(Size.class);
　　　　　　　　//　Utilisez la méthode putAll()
　　　　　　　　sizes2.putAll(sizes1);
　　　　　　　　sizes2.put(Size.LARGE,　36);
　　　　　　　　System.out.println("EnumMap2: "　+　sizes2);
　　　　}
}

Résultat de la sortie

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

Dans l'exemple précédent, nous utilisons la méthode putAll() pour insérer la cartographie d'énumération size1Tous les éléments de l'ensemble dans size2de la cartographie d'énumération.

Vous pouvez également utiliser putAll() pour insérer les éléments d'autres mappings (comme HashMap, TreeMap, etc.) dans la cartographie d'énumération. Cependant, tous les mappings doivent avoir le même type d'énumération.

Accéder aux éléments de EnumMap

1Utilisez entrySet(), keySet() et values()

• entrySet() - Renvoie toutes les clés de la cartographie d'énumération/L'ensemble des éléments de la cartographie de valeurs (entrée)

• keySet() - Renvoie l'ensemble des clés de la cartographie d'énumération

• values() - Retourner l'ensemble de toutes les valeurs de la carte d'enumeration

Par exemple,

import　java.util.EnumMap;
class　Main　{
　　　　enum　Size　{
　　　　　　　　SMALL,　MEDIUM,　LARGE,　EXTRALARGE
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　Créer un EnumMap pour l'enum 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);
　　　　　　　　//　Utiliser la méthode entrySet()
　　　　　　　　System.out.println("Clé/Mapping des valeurs:　+　sizes.entrySet());
　　　　　　　　//　Utiliser la méthode keySet()
　　　　　　　　System.out.println("Clés: ",　+　sizes.keySet());
　　　　　　　　//　Utiliser la méthode values()
　　　　　　　　System.out.println("Valeurs: ",　+　sizes.values());
　　　　}
}

Résultat de la sortie

EnumMap:　{SMALL=28,　MEDIUM=32,　LARGE=36,　EXTRALARGE=40}
Clé/Mapping des valeurs: [SMALL=28,　MEDIUM=32,　LARGE=36,　EXTRALARGE=40]
Clés: [SMALL, MEDIUM, LARGE, EXTRALARGE]
Valeurs: [28,　32,　36,　40]

2.Utiliser la méthode get()

La méthode get() retourne la valeur associée à la clé spécifiée. Si la clé spécifiée n'est pas trouvée, elle retourne null.

Par exemple,

import　java.util.EnumMap;
class　Main　{
　　　　enum　Size　{
　　　　　　　　SMALL,　MEDIUM,　LARGE,　EXTRALARGE
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　Créer un EnumMap pour l'enum 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);
　　　　　　　　//　Utiliser la méthode get()
　　　　　　　　int value = sizes.get(Size.MEDIUM);
　　　　　　　　System.out.println("Valeur de MEDIUM: ",　+　value);
　　　　}
}

Résultat de la sortie

EnumMap:　{SMALL=28,　MEDIUM=32,　LARGE=36,　EXTRALARGE=40}
Valeur de MEDIUM:　32

Supprimer l'élément EnumMap

• remove(key) - Retourner et supprimer l'entrée associée à la clé spécifiée de la carte

• remove(key, value) - Supprimer l'entrée de la carte uniquement si la clé spécifiée est associée à la valeur spécifiée et que le retour est un booléen

Par exemple,

import　java.util.EnumMap;
class　Main　{
　　　　enum　Size　{
　　　　　　　　SMALL,　MEDIUM,　LARGE,　EXTRALARGE
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　Créer un EnumMap pour l'enum 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);
　　　　　　　　//　Utiliser la méthode remove()
　　　　　　　　int value = sizes.remove(Size.MEDIUM);
　　　　　　　　System.out.println("Valeur supprimée: ",　+　value);
　　　　　　　　boolean result = sizes.remove(Size.SMALL,　28);
　　　　　　　　System.out.println("Entrée {SMALL=",28} a été supprimé? \　+　result);
　　　　　　　　System.out.println("EnumMap mis à jour: ",　+　sizes);
　　　　}
}

Résultat de la sortie

EnumMap:　{SMALL=28,　MEDIUM=32,　LARGE=36,　EXTRALARGE=40}
Valeur supprimée:　32
Entrée {SMALL=28} a été supprimé? True
EnumMap mis à jour: {LARGE=36,　EXTRALARGE=40}

Remplacer l'élément EnumMap

• replace(key, value) - Remplacer la valeur associée à la clé key par value

• replace(key, old, new) -　 Ne remplacer l'ancienne valeur par la nouvelle valeur que si l'ancienne valeur est déjà associée à la clé spécifiée

• replaceAll(function) - Remplacer chaque valeur de la correspondance par le résultat de la fonction spécifiée

import　java.util.EnumMap;
class　Main　{
　　　　enum　Size　{
　　　　　　　　SMALL,　MEDIUM,　LARGE,　EXTRALARGE
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　Créer un EnumMap pour l'enum 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);
　　　　　　　　//　Utilisez la méthode replace()
　　　　　　　　sizes.replace(Size.MEDIUM,　30);
　　　　　　　　sizes.replace(Size.LARGE,　36,　34);
　　　　　　　　System.out.println("EnumMap　méthode d'utilisation　replace():　"　+　sizes);
　　　　　　　　//　Utilisez la méthode replaceAll()
　　　　　　　　sizes.replaceAll((key,　oldValue)　->　oldValue　+　3);
　　　　　　　　System.out.println("EnumMap　méthode d'utilisation　replaceAll():　"　+　sizes);
　　　　}
}

Résultat de la sortie

EnumMap:　{SMALL=28,　MEDIUM=32,　LARGE=36,　EXTRALARGE=40}
EnumMap　méthode d'utilisation　replace():　{SMALL=28,　MEDIUM=30,　LARGE=34,　EXTRALARGE=40}
EnumMap　méthode d'utilisation　replaceAll():　{SMALL=31,　MEDIUM=33,　LARGE=37,　EXTRALARGE=43}

Dans le programme ci-dessus, veuillez noter les instructions suivantes

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

Dans ce cas, cette méthode accède à tous les éléments du map. Ensuite, il remplace toutes les valeurs parExpression lambdaNouvelles valeurs fournies.

Autres méthodes

La différence entre EnumSet et EnumMap

EnumSetAnd EnumMap class both provide data structures for storing enum values. However, there are some major differences between them.

• Enum sets are internally represented as bit sequences, while enum mappings are internally represented as arrays.

• Enum sets are created using predefined methods such as allOf(), noneOf(), of(), etc. However, enum mappings are created using their constructor.

Cloneable and Serializable interfaces

The EnumMap class also implements the Cloneable and Serializable interfaces.

Cloneable CloneInterface

It allows the EnumMap class to copy instances of the class.

Serializable serializable interface

Whenever it is necessary to transmit a Java object over a network, it is necessary to convert the object into bits or bytes. This is because Java objects cannot be transmitted over a network.

The Serializable interface allows classes to be serialized. This means that Serializable can convert the objects of the implemented class into bits or bytes.