Java - La Classe IdentityHashMap

Introduction

Bonjour à vous, futurs développeurs Java ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde de la classe IdentityHashMap de Java. Je sais ce que vous pouvez penser : "Encore une classe de carte ? Avons-nous pas juste appris sur HashMap ?" Eh bien, vous avez raison, mais croyez-moi, IdentityHashMap a son propre goût unique qui le rend spécial. Plongeons-y !

Java - The IdentityHashMap Class

Déclaration de Classe

Tout d'abord, regardons comment nous déclarons une IdentityHashMap :

import java.util.IdentityHashMap;

IdentityHashMap<String, Integer> monMap = new IdentityHashMap<>();

Cette ligne de code crée une nouvelle IdentityHashMap qui stockera des clés de type String et des valeurs de type Integer. Mais qu'est-ce qui le rend différent d'un HashMap ordinaire ? Eh bien, c'est là que les choses deviennent intéressantes !

Constructeurs de Classe

IdentityHashMap est fournie avec quatre constructeurs. Analysons-les :

Constructeur par défaut :
```
IdentityHashMap<String, Integer> map1 = new IdentityHashMap<>();
```
Cela crée une IdentityHashMap vide avec une capacité par défaut de 21.
Constructeur avec capacité initiale :
```
IdentityHashMap<String, Integer> map2 = new IdentityHashMap<>(100);
```
Cela crée une IdentityHashMap vide avec la capacité initiale spécifiée.

Constructeur avec une autre Map :

Map<String, Integer> mapExistante = new HashMap<>();
IdentityHashMap<String, Integer> map3 = new IdentityHashMap<>(mapExistante);

Cela crée une IdentityHashMap avec les mêmes mappages que la Map spécifiée.

Constructeur avec taille maximale attendue :
```
IdentityHashMap<String, Integer> map4 = new IdentityHashMap<>(100, 0.75f);
```
Cela crée une IdentityHashMap vide avec la taille maximale attendue et le facteur de charge spécifiés.

Méthodes de Classe

Maintenant, examinons algumas des méthodes les plus couramment utilisées dans IdentityHashMap :

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 à laquelle la clé spécifiée est mappée
remove(Object key)	Supprime le mappage pour cette clé si présent
clear()	Supprime tous les mappages de cette carte
size()	Retourne le nombre de mappages clé-valeur dans cette carte
isEmpty()	Retourne true si cette carte ne contient aucun mappage clé-valeur
containsKey(Object key)	Retourne true si cette carte contient un mappage pour la clé spécifiée
containsValue(Object value)	Retourne true si cette carte mappe une ou plusieurs clés à la valeur spécifiée

Voyons algunas de ces méthodes en action :

IdentityHashMap<String, Integer> ages = new IdentityHashMap<>();

// Ajout de paires clé-valeur
ages.put("Alice", 25);
ages.put("Bob", 30);

// Obtenir une valeur
System.out.println("Age d'Alice : " + ages.get("Alice")); // Sortie : Age d'Alice : 25

// Vérifier si une clé existe
System.out.println("Charlie existe-t-il ? " + ages.containsKey("Charlie")); // Sortie : Charlie existe-t-il ? false

// Supprimer une paire clé-valeur
ages.remove("Bob");

// Vérifier la taille
System.out.println("Nombre d'entrées : " + ages.size()); // Sortie : Nombre d'entrées : 1

Méthodes Héritées

IdentityHashMap hérite des méthodes de ses classes parentes et interfaces. Voici quelques-unes d'entre elles :

Hérité De	Méthodes
java.util.AbstractMap	clone(), equals(), hashCode(), toString()
java.util.Map	entrySet(), keySet(), values()
java.lang.Object	finalize(), getClass(), notify(), notifyAll(), wait()

Exemple d'Ajout d'un Mappage Clé-Valeur dans une IdentityHashMap

Maintenant, plongeons dans ce qui rend IdentityHashMap spéciale. Contrairement à HashMap, qui utilise la méthode equals() pour comparer les clés, IdentityHashMap utilise l'égalité de référence (==). Cela signifie que deux clés sont considérées égales uniquement si elles sont le même objet en mémoire.

Voyons cela en action :

IdentityHashMap<String, String> identityMap = new IdentityHashMap<>();

String key1 = new String("Bonjour");
String key2 = new String("Bonjour");

identityMap.put(key1, "Monde1");
identityMap.put(key2, "Monde2");

System.out.println("Taille de IdentityHashMap : " + identityMap.size());
System.out.println("Valeur pour key1 : " + identityMap.get(key1));
System.out.println("Valeur pour key2 : " + identityMap.get(key2));

Sortie :

Taille de IdentityHashMap : 2
Valeur pour key1 : Monde1
Valeur pour key2 : Monde2

Surpris ? Même si key1 et key2 ont le même contenu ("Bonjour"), IdentityHashMap les traite comme des clés différentes parce qu'elles sont des objets String différents en mémoire.

Ce comportement peut être extrêmement utile dans certains scénarios. Par exemple, imaginez que vous écrivez un programme pour suivre les différentes versions d'un document. Chaque version pourrait avoir le même titre, mais vous voulez les traiter comme des entités séparées. IdentityHashMap serait parfait pour cela !

En conclusion, IdentityHashMap est comme le cousin excentrique de la famille Map. Il ressemble aux autres, mais il a sa propre manière unique de faire les choses. Comprendre quand l'utiliser peut vous rendre un programmeur Java plus polyvalent.

N'oubliez pas, dans le monde de la programmation, il n'y a pas de solution unique. Chaque outil a son place, et savoir quand utiliser IdentityHashMap est un autre trait dans votre carquois de connaissances Java. Continuez à pratiquer, restez curieux, et bon codage !

Credits: Image by storyset