Guidé debutant pour la classe WeakHashMap de Java

Introduction

Bonjour à toi, futurs programmeurs Java !aujourd'hui, nous allons plonger dans le monde fascinant de WeakHashMap en Java. Ne t'inquiète pas si tu n'as jamais entendu parler de cela avant - nous commencerons desde le début et nous nous déplacerons vers le haut. À la fin de ce tutoriel, tu seras un expert en WeakHashMap !

Java - WeakHashMap

Qu'est-ce qu'une WeakHashMap ?

Imagine que tu organises un grand parti, et que tu as une liste d'invités. Mais ce n'est pas n'importe quelle liste d'invités - c'est une liste magique qui supprime automatiquement les personnes qui ne peuvent plus y participer. C'est un peu ce qu'une WeakHashMap fait en Java, mais avec des objets au lieu d'invités de party !

Une WeakHashMap est un type spécial de Map en Java qui permet à ses clés d'être recycler par le ramasse-miettes lorsequ'elles ne sont plus utilisées ailleurs dans ton programme. Cela peut être vraiment utile lorsque vous voulez créer un cache qui ne empêche pas les objets d'être nettoyés lorsequ'ils ne sont plus nécessaires.

Déclaration de classe

Commençons par regarder comment nous déclarons une WeakHashMap :

import java.util.WeakHashMap;

public class WeakHashMapExample {
public static void main(String[] args) {
WeakHashMap<String, Integer> myWeakMap = new WeakHashMap<>();
}
}

Dans cet exemple, nous créons une WeakHashMap qui utilise des objets String comme clés et des objets Integer comme valeurs. La partie <String, Integer> est appelée "génériques" - c'est comme dire à Java quels types d'objets nous voulons stocker dans notre carte.

Constructeurs de classe

WeakHashMap est fourni avec quatre constructeurs différents. Regardons chacun d'eux :

Constructeur par défaut :
```
WeakHashMap<String, Integer> map1 = new WeakHashMap<>();
```
Cela crée une WeakHashMap vide avec la capacité initiale par défaut (16) et le facteur de charge (0.75).
Constructeur avec capacité initiale :
```
WeakHashMap<String, Integer> map2 = new WeakHashMap<>(100);
```
Cela crée une WeakHashMap avec la capacité initiale spécifiée et le facteur de charge par défaut.
Constructeur avec capacité initiale et facteur de charge :
```
WeakHashMap<String, Integer> map3 = new WeakHashMap<>(100, 0.8f);
```
Cela crée une WeakHashMap avec la capacité initiale et le facteur de charge spécifiés.

Constructeur avec une autre Map :

Map<String, Integer> existingMap = new HashMap<>();
existingMap.put("Alice", 25);
existingMap.put("Bob", 30);
WeakHashMap<String, Integer> map4 = new WeakHashMap<>(existingMap);

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

Méthodes de classe

WeakHashMap fournit plusieurs méthodes pour manipuler et accéder à ses contenus. Voici un tableau des méthodes les plus couramment utilisées :

Méthode	Description
put(K key, V value)	Ajoute une paire clé-valeur à la carte
get(Object key)	Récupère la valeur associée à la clé spécifiée
remove(Object key)	Supprime le mappage pour la clé spécifiée
size()	Retourne le nombre de mappages clé-valeur dans la carte
clear()	Supprime tous les mappages de la carte
containsKey(Object key)	Retourne vrai si la carte contient la clé spécifiée
containsValue(Object value)	Retourne vrai si la carte contient la valeur spécifiée
isEmpty()	Retourne vrai si la carte ne contient pas de mappages clé-valeur

Regardons certaines de ces méthodes en action :

WeakHashMap<String, Integer> ageMap = new WeakHashMap<>();

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

// Récupération d'une valeur
System.out.println("Age d'Alice : " + ageMap.get("Alice")); // Sortie : Age d'Alice : 25

// Vérification de l'existence d'une clé
System.out.println("Est-ce que David est dans la carte ? " + ageMap.containsKey("David")); // Sortie : Est-ce que David est dans la carte ? false

// Suppression d'une paire clé-valeur
ageMap.remove("Bob");
System.out.println("Taille de la carte après suppression de Bob : " + ageMap.size()); // Sortie : Taille de la carte après suppression de Bob : 2

// Effacement de la carte
ageMap.clear();
System.out.println("Est-ce que la carte est vide ? " + ageMap.isEmpty()); // Sortie : Est-ce que la carte est vide ? true

Méthodes héritées

WeakHashMap hérite des méthodes de ses classes parentes et interfaces. Voici quelques-unes des méthodes héritées importantes :

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'une paire clé-valeur à une WeakHashMap de paires Integer, Integer

Maintenant, regardons un exemple plus complet de l'utilisation d'une WeakHashMap avec des clés et des valeurs Integer :

import java.util.WeakHashMap;

public class WeakHashMapExample {
public static void main(String[] args) {
WeakHashMap<Integer, Integer> squareMap = new WeakHashMap<>();

// Ajout de paires clé-valeur
for (int i = 1; i <= 5; i++) {
squareMap.put(i, i * i);
}

System.out.println("Carte initiale : " + squareMap);

// Accès aux valeurs
System.out.println("Carré de 3 : " + squareMap.get(3));

// Suppression d'une paire clé-valeur
squareMap.remove(2);
System.out.println("Carte après suppression de 2 : " + squareMap);

// Vérification de l'existence d'une clé
System.out.println("La carte contient-elle 4 ? " + squareMap.containsKey(4));

// Vérification de l'existence d'une valeur
System.out.println("La carte contient-elle la valeur 16 ? " + squareMap.containsValue(16));

// Itération sur la carte
System.out.println("Itération sur la carte :");
for (Integer key : squareMap.keySet()) {
System.out.println("Clé : " + key + ", Valeur : " + squareMap.get(key));
}
}
}

Sortie

Lorsque vous exécutez ce code, vous verrez une sortie similaire à ceci :

Carte initiale : {5=25, 4=16, 3=9, 2=4, 1=1}
Carré de 3 : 9
Carte après suppression de 2 : {5=25, 4=16, 3=9, 1=1}
La carte contient-elle 4 ? true
La carte contient-elle la valeur 16 ? true
Itération sur la carte :
Clé : 5, Valeur : 25
Clé : 4, Valeur : 16
Clé : 3, Valeur : 9
Clé : 1, Valeur : 1

Et voilà ! Tu as juste pris tes premiers pas dans le monde de WeakHashMap en Java. N'oublie pas, la véritable puissance de WeakHashMap vient de sa capacité à permettre aux clés d'être recycler par le ramasse-miettes lorsequ'elles ne sont plus référencées ailleurs dans ton programme. Cela peut être extrêmement utile dans certains scénarios, comme l'implémentation de caches ou la gestion de données temporaires.

À mesure que tu continues ton voyage en Java, tu découvriras de plus en plus de situations où WeakHashMap peut être un outil précieux dans ton boîte à outils de programmation. Continue à pratiquer, à explorer et, surtout, amuse-toi à coder !

Credits: Image by storyset