KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

WeakHashMap: koppelingen toevoegen, opvragen, testen en tellen

Leer hoe vijf bewerkingen van `WeakHashMap` in Java SE 21 omgaan met zwakke sleutels, sterke waarden en de verschillende betekenissen van `null`.

Versie: Java SE 21

Syntax

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> houdt sleutels die niet null zijn vast via zwakke referenties en waarden via sterke referenties. Zodra een sleutelobject zwak bereikbaar wordt, kan de garbagecollector (GC) zijn zwakke referentie wissen. Daarna kan de map de koppeling verwijderen. Er is geen gegarandeerde termijn. Een direct of indirect pad van sterke referenties van een waarde naar zijn eigen sleutel kan dit verhinderen.

Bij het opzoeken van sleutels gebruikt de map hashCode() en equals(), niet alleen objectidentiteit (==). Een ander maar gelijk object kan een koppeling vinden, maar houdt het opgeslagen sleutelobject niet op zichzelf in leven. De map staat één null-sleutel en null-waarden toe.

put(K key, V value) voegt een koppeling toe of vervangt de waarde voor een gelijke sleutel. De methode geeft de vorige waarde terug, of null als er nog geen koppeling was of de vorige waarde null was. get(Object key) geeft de huidige waarde terug; null staat voor zowel een ontbrekende koppeling als een gekoppelde null-waarde. containsKey(Object key) controleert of de koppeling bestaat ongeacht de waarde en maakt zo het onderscheid. Twee aanroepen vormen geen enkele atomaire waarneming.

containsValue(Object value) controleert of minstens één koppeling een gelijke waarde heeft; je kunt ook naar null zoeken. size() telt de koppelingen op het moment van de aanroep, ook die met de waarde null. De uitkomsten kunnen veranderen zonder schrijfactie van de applicatie, doordat de map koppelingen opruimt nadat de GC hun sleutelreferenties heeft gewist.

De map biedt geen TTL (verval na een bepaalde tijd) en geen LRU (verwijdering van de langst niet gebruikte koppeling). Ze is niet thread-safe. Collections.synchronizedMap(...) kan gedeelde toegang synchroniseren, maar voorkomt GC-gerelateerde opruiming niet.

Voorbeelden

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);
    }
}

Resultaat

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` is een ander object dan `stored`, maar is er wel gelijk aan: het vervangt `draft` door `ready` zonder een koppeling toe te voegen. `get` geeft zowel voor de `null`-sleutel als voor `missing` de waarde `null` terug, maar alleen de eerste is aanwezig. `Reference.reachabilityFence` houdt beide sleutelobjecten sterk bereikbaar tot en met de laatste uitvoerregel; het voorbeeld test niet wanneer de GC opruimt.

Gerelateerde lessen

  • Java · Les 18 · Gevorderd · Versie: 2

Bronnen