Java WeakHashMap – Compréhension, Utilisation et Différences Clés

Java WeakHashMap

Un guide complet sur WeakHashMap de Java, couvrant sa création, différences clés avec HashMap, exemples pratiques et méthodes essentielles.

La classe WeakHashMap fait partie du Java Collections Framework et implémente l'interface Map. Elle se comporte comme une table de hachage normale mais stocke les clés sous forme de références faibles, leur permettant d'être récupérées par le garbage collector quand elles ne sont plus utilisées.

Note : Les clés dans un WeakHashMap sont enveloppées dans des objets WeakReference.

Une référence faible peut être garbage-collectée si le programme ne détient plus de référence forte vers l'objet clé.

---

Création d'un WeakHashMap

Importez d'abord java.util.WeakHashMap :

import java.util.WeakHashMap;

Puis instanciez-le, en spécifiant optionnellement une capacité initiale et un facteur de charge :

// WeakHashMap avec capacité 8 et facteur de charge 0.6
WeakHashMap<Key, Value> numbers = new WeakHashMap<>(8, 0.6);

Paramètres :

• capacity – le nombre d'entrées que la map peut contenir avant redimensionnement. Défaut 16.
• loadFactor – le seuil auquel la map s'étend. Défaut 0.75.

Sans paramètres, les valeurs par défaut s'appliquent :

WeakHashMap<Key, Value> numbers = new WeakHashMap<>();

---

HashMap vs WeakHashMap

Bien que les deux implémentent Map, la distinction clé réside dans la force de référence :

• HashMap – les clés sont des références fortes ; les entrées persistent jusqu'à suppression explicite.
• WeakHashMap – les clés sont des références faibles ; les entrées disparaissent quand la clé n'est plus accessible.

Exemple démontrant le comportement :

import java.util.WeakHashMap;
class Main {
    public static void main(String[] args) {
        WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
        String two = new String("Two");
        Integer twoValue = 2;
        String four = new String("Four");
        Integer fourValue = 4;
        numbers.put(two, twoValue);
        numbers.put(four, fourValue);
        System.out.println("WeakHashMap: " + numbers);
        // Annuler la référence vers la clé two
        two = null;
        System.gc();
        System.out.println("WeakHashMap après GC: " + numbers);
    }
}

Sortie :

WeakHashMap: {Four=4, Two=2} WeakHashMap après GC: {Four=4}

L'entrée pour "Two" disparaît car sa clé n'est plus fortement accessible. En revanche, un HashMap retiendrait l'entrée :

import java.util.HashMap;
class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> numbers = new HashMap<>();
        String two = new String("Two");
        Integer twoValue = 2;
        String four = new String("Four");
        Integer fourValue = 4;
        numbers.put(two, twoValue);
        numbers.put(four, fourValue);
        System.out.println("HashMap: " + numbers);
        two = null;
        System.gc();
        System.out.println("HashMap après GC: " + numbers);
    }
}

Sortie :

HashMap: {Four=4, Two=2} HashMap après GC: {Four=4, Two=2}

Ainsi, WeakHashMap est idéal quand vous voulez que la map libère automatiquement la mémoire liée aux clés inutilisées.

---

Conversion depuis une Autre Map

Instanciez un WeakHashMap depuis une map existante pour copier ses entrées :

import java.util.HashMap;
import java.util.WeakHashMap;
class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> evenNumbers = new HashMap<>();
        String two = new String("Two");
        evenNumbers.put(two, 2);
        System.out.println("HashMap: " + evenNumbers);
        WeakHashMap<String, Integer> numbers = new WeakHashMap<>(evenNumbers);
        System.out.println("WeakHashMap: " + numbers);
    }
}

Sortie :

HashMap: {Two=2} WeakHashMap: {Two=2}

---

Méthodes Clés de WeakHashMap

Voici une sélection des opérations les plus fréquemment utilisées.

Insertion d'Entrées

• put(key, value) – ajoute un mapping.
• putAll(map) – fusionne une autre map.
• putIfAbsent(key, value) – insère seulement si la clé est absente.

Exemple :

import java.util.WeakHashMap;
class Main {
    public static void main(String[] args) {
        WeakHashMap<String, Integer> evenNumbers = new WeakHashMap<>();
        evenNumbers.put(new String("Two"), 2);
        evenNumbers.putIfAbsent(new String("Four"), 4);
        System.out.println("Nombres pairs: " + evenNumbers);
        WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
        numbers.put(new String("One"), 1);
        numbers.putAll(evenNumbers);
        System.out.println("Tous les nombres: " + numbers);
    }
}

Sortie :

Nombres pairs: {Four=4, Two=2} Tous les nombres: {Two=2, Four=4, One=1}

Accès aux Entrées

Récupérez les données via :

• get(key) – retourne la valeur ou null si absente.
• getOrDefault(key, default) – retourne une valeur par défaut quand la clé manque.
• entrySet(), keySet(), values() – itérez sur entrées, clés ou valeurs.

Exemple :

import java.util.WeakHashMap;
class Main {
    public static void main(String[] args) {
        WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
        numbers.put(new String("One"), 1);
        numbers.put(new String("Two"), 2);
        System.out.println("Map: " + numbers);
        System.out.println("Ensemble entrées: " + numbers.entrySet());
        System.out.println("Clés: " + numbers.keySet());
        System.out.println("Valeurs: " + numbers.values());
        System.out.println("Get Two: " + numbers.get("Two"));
        System.out.println("GetOrDefault Four: " + numbers.getOrDefault("Four", 4));
    }
}

Sortie :

Map: {Two=2, One=1} Ensemble entrées: [Two=2, One=1] Clés: [Two, One] Valeurs: [1, 2] Get Two: 2 GetOrDefault Four: 4

Suppression d'Entrées

• remove(key) – supprime et retourne la valeur.
• remove(key, value) – supprime seulement si le mapping courant correspond à la valeur fournie.
• clear() – vide la map.
• containsKey(key), containsValue(value), size(), isEmpty()

Exemple :

import java.util.WeakHashMap;
class Main {
    public static void main(String[] args) {
        WeakHashMap<String, Integer> numbers = new WeakHashMap<>();
        numbers.put(new String("One"), 1);
        numbers.put(new String("Two"), 2);
        System.out.println("Map: " + numbers);
        int removed = numbers.remove("Two");
        System.out.println("Valeur supprimée: " + removed);
        boolean removedIf = numbers.remove("One", 3);
        System.out.println("Supprimé {One=3}? " + removedIf);
        System.out.println("Après suppression: " + numbers);
    }
}

Sortie :

Map: {Two=2, One=1} Valeur supprimée: 2 Supprimé {One=3}? false Après suppression: {One=1}

---

Utilitaires Supplémentaires

Méthode	Description
clear()	Supprime toutes les entrées.
containsKey(key)	Vérifie si la clé existe.
containsValue(value)	Vérifie si une valeur est présente.
size()	Retourne le nombre d'entrées.
isEmpty()	Retourne true si la map n'a pas d'entrées.

Pour une analyse plus approfondie, référez-vous à la documentation officielle Java WeakHashMap.