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