Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

WeakHashMap: inserir, ler, verificar e contar entradas

Aprende como funcionam cinco operações de `WeakHashMap` em Java SE 21 quando o mapa usa chaves fracas, valores fortes e aceita `null`.

Versão: Java SE 21

Sintaxe

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> mantém as chaves diferentes de null por referências fracas e os valores por referências fortes. Quando um objeto chave passa a ser fracamente alcançável, o coletor de lixo (GC) pode limpar a sua referência fraca e o mapa pode depois remover a entrada. Não há um prazo garantido. Uma cadeia de referências fortes, direta ou indireta, de um valor até à sua própria chave pode impedir a remoção.

A pesquisa por chave usa hashCode() e equals(), não apenas a identidade do objeto (==). Um objeto diferente mas igual pode encontrar a entrada, mas não mantém, por si só, o objeto chave guardado em uso. O mapa aceita uma chave null e valores null.

put(K key, V value) adiciona uma associação ou substitui o valor de uma chave igual. Devolve o valor anterior, ou null se não existia associação ou se o valor anterior era null. get(Object key) devolve o valor atual; null pode significar que a associação não existe ou que o valor associado é null. containsKey(Object key) testa se existe uma associação, independentemente do valor, e distingue estes casos. Duas chamadas não constituem uma única observação atómica.

containsValue(Object value) testa se pelo menos uma associação tem um valor igual ao procurado, incluindo null quando se procura esse valor. size() conta as associações no momento da chamada, incluindo as que têm valor null. Os resultados podem mudar sem escritas da aplicação quando o mapa remove entradas após o GC limpar as respetivas referências às chaves.

O mapa não fornece TTL (expiração ao fim de um prazo) nem LRU (remoção da entrada utilizada há mais tempo). Não é seguro para acesso concorrente: Collections.synchronizedMap(...) pode sincronizar o acesso partilhado, mas não impede a limpeza associada ao GC.

Exemplos

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` é um objeto distinto de `stored`, mas igual a ele: substitui `draft` por `ready` sem adicionar uma associação. `get` devolve `null` tanto para a chave `null` como para `missing`, mas só a primeira está presente. `Reference.reachabilityFence` mantém ambos os objetos chave fortemente alcançáveis até à última linha da saída; o exemplo não testa o momento em que o GC atua.

Lições relacionadas

  • Java · Lição 18 · Avançado · Versão: 2

Fontes