CKTIS / Java
WeakHashMap: insertar, leer, comprobar y contar entradas
Aprende cómo se comportan cinco operaciones de `WeakHashMap` en Java SE 21 con claves débiles, valores fuertes y asociaciones que admiten `null`.
Versión: Java SE 21
Sintaxis
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> conserva las claves no nulas mediante referencias débiles y los valores mediante referencias fuertes. Cuando un objeto clave pasa a ser débilmente alcanzable, el recolector de basura (GC) puede borrar su referencia débil y el mapa puede eliminar después la entrada. No hay un plazo garantizado. Una cadena directa o indirecta de referencias fuertes desde un valor hasta su propia clave puede impedirlo.
La búsqueda de claves usa hashCode() y equals(), no solo la identidad del objeto (==). Un objeto distinto pero igual puede encontrar una entrada, pero no mantiene por sí solo con vida el objeto clave almacenado. El mapa admite una clave null y valores null.
put(K key, V value) añade una asociación o sustituye el valor de una clave igual. Devuelve el valor anterior, o null si no había asociación o si el valor anterior era null. get(Object key) devuelve el valor actual; null puede indicar tanto una asociación ausente como una asociación con valor null. containsKey(Object key) comprueba si existe la asociación independientemente de su valor y distingue esos casos. Dos llamadas no constituyen una única observación atómica.
containsValue(Object value) comprueba si al menos una asociación tiene un valor igual al buscado, incluido null si se busca ese valor. size() cuenta las asociaciones en el momento de la llamada, incluidas las que tienen un valor null. Los resultados pueden cambiar sin que la aplicación escriba en el mapa, cuando este retira entradas cuyas referencias de clave ha borrado el GC.
El mapa no ofrece TTL (caducidad temporal) ni LRU (expulsión de la entrada usada hace más tiempo). No es seguro para el acceso concurrente: Collections.synchronizedMap(...) puede sincronizar el acceso compartido, pero no impide la limpieza asociada al GC.
Ejemplos
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);
}
}Resultado
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` es un objeto distinto de `stored`, pero igual a él: sustituye `draft` por `ready` sin añadir una asociación. `get` devuelve `null` tanto para la clave `null` como para `missing`, pero solo está presente la primera. `Reference.reachabilityFence` mantiene ambos objetos clave fuertemente alcanzables hasta la última impresión; el ejemplo no comprueba cuándo actúa el GC.
Lecciones relacionadas
- Java · Lección 18 · Avanzado · Versión: 2