Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

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

Fuentes