EnumMap Class Java : Guide pour Débutants

Introduction

Salut les futurs programmeurs Java ! Aujourd'hui, nous allons entamer un voyage passionnant dans le monde de la classe EnumMap de Java. Je sais ce que vous pouvez penser : "EnumMap ? Ça a l'air compliqué !" Mais ne vous inquiétez pas ! À la fin de ce tutoriel, vous utiliserez des EnumMaps comme un pro, et vous pourriez même vous amuser un peu en chemin.

Java - EnumMap

Commençons par une analogie simple. Imaginez que vous avez un tiroir spécial pour chaque jour de la semaine pour organiser vos chaussettes. C'est essentiellement ce qu'est un EnumMap – une manière d'organiser des données en utilisant des constantes d'énumération comme clés. Cool, non ? Plongeons-y !

Déclaration de Classe

Tout d'abord, regardons comment nous déclarons un EnumMap :

import java.util.EnumMap;

enum DaysOfWeek { LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI, DIMANCHE }

EnumMap<DaysOfWeek, String> activites = new EnumMap<>(DaysOfWeek.class);

Dans cet exemple, nous créons un EnumMap qui utilise notre énumération DaysOfWeek comme clés et des valeurs String pour stocker des activités. La partie DaysOfWeek.class indique à Java quel énumération nous utilisons pour nos clés.

Constructeurs de Classe

EnumMap a trois constructeurs. Regardons-les chacun :

EnumMap(Class keyType)
```
EnumMap<DaysOfWeek, String> activites = new EnumMap<>(DaysOfWeek.class);
```
Cela crée un EnumMap vide avec des clés du type d'énumération spécifié.
EnumMap(EnumMap<K,? extends V> m)
```
EnumMap<DaysOfWeek, String> activitesCopy = new EnumMap<>(activites);
```
Cela crée un EnumMap avec le même type de clé que l'EnumMap spécifié et l'initialise avec les mêmes mappages (s'il y en a).

EnumMap(Map<K,? extends V> m)

Map<DaysOfWeek, String> regularMap = new HashMap<>();
regularMap.put(DaysOfWeek.LUNDI, "Gym");
EnumMap<DaysOfWeek, String> activitesFromMap = new EnumMap<>(regularMap);

Cela crée un EnumMap initialisé à partir d'un Map ordinaire.

Méthodes de Classe

Maintenant, regardons某些 des méthodes les plus couramment utilisées dans EnumMap :

Méthode	Description
put(K key, V value)	Associe la valeur spécifiée à la clé spécifiée
get(Object key)	Retourne la valeur associée à la clé spécifiée
remove(Object key)	Supprime le mappage pour cette clé si présent
size()	Retourne le nombre de mappages clé-valeur
clear()	Supprime tous les mappages de ce map
containsKey(Object key)	Retourne vrai si ce map contient un mappage pour la clé spécifiée
containsValue(Object value)	Retourne vrai si ce map mappe un ou plusieurs clés à la valeur spécifiée

Regardons ces méthodes en action :

EnumMap<DaysOfWeek, String> activites = new EnumMap<>(DaysOfWeek.class);

// Ajout de paires clé-valeur
activites.put(DaysOfWeek.LUNDI, "Gym");
activites.put(DaysOfWeek.MARDI, "Cinéma");

// Obtenir une valeur
String lundiActivity = activites.get(DaysOfWeek.LUNDI);
System.out.println("Activité de Lundi : " + lundiActivity);

// Vérifier si une clé existe
boolean hasWednesday = activites.containsKey(DaysOfWeek.MERCREDI);
System.out.println("Avoir Mercredi : " + hasWednesday);

// Supprimer une paire clé-valeur
activites.remove(DaysOfWeek.MARDI);

// Obtenir la taille
int size = activites.size();
System.out.println("Nombre d'activités : " + size);

// Effacer le map
activites.clear();

Dans cet exemple, nous ajoutons des activités pour différents jours, récupérons des valeurs, vérifions les clés, supprimons des entrées et finalement effaçons tout le map. C'est comme organiser et réorganiser notre tiroir à chaussettes !

Méthodes Héritées

EnumMap hérite des méthodes de ses classes parentes. Voici quelques-unes utiles :

Méthode	Héritée De	Description
clone()	AbstractMap	Crée une copie superficielle de ce map
equals(Object o)	AbstractMap	Compare l'objet spécifié avec ce map pour l'égalité
hashCode()	AbstractMap	Retourne la valeur de hachage pour ce map
toString()	AbstractMap	Retourne une représentation sous forme de chaîne de ce map

Exemple d'ajout de Paire Clé-Valeur à un EnumMap d'Enum, Paire Entier

Maintenant, essayons quelque chose de plus complexe. Nous allons créer un EnumMap qui utilise une énumération comme clés et des entiers comme valeurs :

enum Fruit { POMME, BANANE, ORANGE, MANGUE }

EnumMap<Fruit, Integer> prixFruits = new EnumMap<>(Fruit.class);

// Ajout de paires clé-valeur
prixFruits.put(Fruit.POMME, 100);
prixFruits.put(Fruit.BANANE, 80);
prixFruits.put(Fruit.ORANGE, 120);
prixFruits.put(Fruit.MANGUE, 150);

// Impression de l'EnumMap
System.out.println("Prix des Fruits : " + prixFruits);

// Mise à jour d'une valeur
prixFruits.put(Fruit.BANANE, 90);

// Obtenir une valeur spécifique
int prixPomme = prixFruits.get(Fruit.POMME);
System.out.println("Prix de la Pomme : " + prixPomme);

// Itérer sur l'EnumMap
for (Map.Entry<Fruit, Integer> entry : prixFruits.entrySet()) {
System.out.println(entry.getKey() + " : $" + entry.getValue());
}

Dans cet exemple, nous créons une liste de prix de fruits. Nous ajoutons des prix pour différents fruits, mettons à jour le prix des bananes, récupérons le prix des pommes et puis itérons sur l'ensemble du map pour imprimer tous les prix de fruits.

Et voilà ! Vous avez juste appris les bases de la classe EnumMap de Java. Rappelez-vous, la pratique fait le maître, donc n'hésitez pas à expérimenter avec ces concepts. Qui sait ? Vous pourriez vous retrouver à organiser toute votre vie avec des EnumMaps ! (Je plaisante, mais elles sont assez utiles.)

Bonne programmation, et que vos EnumMaps soient toujours bien organisés !

Credits: Image by storyset