CKTIS / Java
WeakHashMap : ajouter, lire, vérifier et compter les associations
Découvrez cinq opérations de `WeakHashMap` en Java SE 21 et l’effet des clés à référence faible, des valeurs à référence forte et de `null` sur leurs résultats.
Version : Java SE 21
Syntaxe
java.util.WeakHashMap<K, V> (Java SE 21)
public V put(K key, V value)
public V get(Object key)
public boolean containsKey(Object key)
public boolean containsValue(Object value)
public int size()java.util.WeakHashMap<K, V> conserve les clés non null par des références faibles et les valeurs par des références fortes. Lorsqu’une clé n’est plus que faiblement accessible, le ramasse-miettes (GC) peut effacer sa référence faible, puis la map peut supprimer l’association. Aucun délai n’est garanti. Une chaîne de références fortes, directe ou indirecte, de la valeur vers sa propre clé peut empêcher ce nettoyage.
La recherche d’une clé repose sur hashCode() et equals(), pas seulement sur l’identité de l’objet (==). Un objet distinct mais égal peut retrouver une association, sans maintenir à lui seul la clé stockée en vie. La map accepte une clé null et des valeurs null.
put(K key, V value) ajoute une association ou remplace la valeur associée à une clé égale. La méthode renvoie l’ancienne valeur, ou null si l’association n’existait pas ou si l’ancienne valeur était null. get(Object key) renvoie la valeur actuelle ; null signifie que l’association est absente ou que sa valeur est null. containsKey(Object key) teste la présence de l’association indépendamment de sa valeur et distingue ces deux cas. Deux appels ne constituent toutefois pas une observation atomique.
containsValue(Object value) vérifie qu’au moins une association a une valeur égale à celle recherchée, y compris si l’on cherche null. size() compte les associations au moment de l’appel, y compris celles dont la valeur est null. Les résultats peuvent changer sans écriture de l’application lorsque la map élimine des associations après l’effacement de leurs références de clé par le GC.
La map ne fournit ni TTL (expiration dans le temps) ni LRU (éviction de l’entrée la moins récemment utilisée). Elle n’est pas sûre en accès concurrent. Collections.synchronizedMap(...) peut synchroniser les accès partagés, mais n’empêche pas le nettoyage lié au GC.
Exemples
import java.lang.ref.Reference;
import java.util.WeakHashMap;
public class WeakHashMapDemo {
record Key(int id) {}
public static void main(String[] args) {
var map = new WeakHashMap<Key, String>();
var stored = new Key(1);
var equal = new Key(1);
var missing = new Key(2);
System.out.println("first put: " + map.put(stored, "draft"));
System.out.println("replacement put: " + map.put(equal, "ready"));
map.put(null, null);
System.out.println("get(equal): " + map.get(equal));
System.out.println("get(null): " + map.get(null));
System.out.println("get(missing): " + map.get(missing));
System.out.println("containsKey(null): " + map.containsKey(null));
System.out.println("containsKey(missing): " + map.containsKey(missing));
System.out.println("containsValue(null): " + map.containsValue(null));
System.out.println("size: " + map.size());
Reference.reachabilityFence(stored);
Reference.reachabilityFence(equal);
}
}Résultat
first put: null replacement put: draft get(equal): ready get(null): null get(missing): null containsKey(null): true containsKey(missing): false containsValue(null): true size: 2
`equal` est distinct de `stored` mais lui est égal : il remplace `draft` par `ready` sans ajouter d’association. `get` renvoie `null` pour la clé `null` comme pour `missing`, mais seule la première est présente. `Reference.reachabilityFence` maintient les deux objets clés fortement accessibles jusqu’au dernier affichage ; l’exemple ne teste pas le moment du nettoyage par le GC.
Leçons associées
- Java · Leçon 18 · Avancé · Version : 2