KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Map.containsKey en Map.put: aanwezige sleutel of null-waarde

Controleer of een map een sleutel bevat, ook als de waarde `null` is. Leer wanneer `put` een item toevoegt of de waarde vervangt, en wat het verschil is met voorwaardelijk invoegen.

Versie: Java SE 21

Syntax

java.util.Map<K, V> — instance method signatures:
boolean containsKey(Object key)
V put(K key, V value)

Map.containsKey(Object key) geeft true terug als de map een item voor de sleutel bevat, zonder de map te wijzigen. Volgens het contract van Map komt een sleutel overeen als Objects.equals(key, k) waar is, met k als opgeslagen sleutel. In een HashMap komt een nieuwe, logisch gelijke sleutel overeen met het bestaande item. IdentityHashMap vergelijkt in plaats daarvan bewust referenties met ==.

In een map die null-waarden toestaat, zoals HashMap, maakt get(key) == null op zichzelf geen onderscheid tussen een ontbrekend item en een item met de waarde null. Gebruik daarvoor containsKey. Bij een ongeschikt sleuteltype kan containsKey een ClassCastException opwerpen, en bij een niet-toegestane null-sleutel een NullPointerException.

Map.put(K key, V value) maakt een item aan voor een ontbrekende sleutel of vervangt de waarde van een bestaand item. De methode geeft de vorige waarde terug, niet de nieuwe. Het resultaat null kan betekenen dat er geen item was of dat de vorige waarde null was. put is optioneel: als een map deze bewerking niet ondersteunt, moet een aanroep die de map zou wijzigen een UnsupportedOperationException opwerpen. Als de aanroep geen effect op de map zou hebben, mag de implementatie die uitzondering opwerpen, maar dat hoeft niet. Welke sleutels en waarden zijn toegestaan, hangt af van de implementatie.

Gebruik if (!map.containsKey(key)) map.put(key, value); om alleen bij een ontbrekende sleutel iets in te voegen en een bestaande null-waarde te behouden. putIfAbsent kan daarentegen een bestaande null-waarde vervangen. De losse controle en schrijfbewerking vormen samen geen atomaire bewerking ten opzichte van andere threads.

Voorbeelden

import java.util.HashMap;
import java.util.Map;

public class MapContainsKeyDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        String storedKey = new String("task");
        String equalKey = new String("task");
        String missingKey = "other";

        map.put(storedKey, null);

        System.out.println("Same reference: " + (storedKey == equalKey));
        System.out.println("Equal key: contains=" + map.containsKey(equalKey)
                + ", get=" + map.get(equalKey));
        System.out.println("Missing key: contains=" + map.containsKey(missingKey)
                + ", get=" + map.get(missingKey));

        if (!map.containsKey(equalKey)) {
            map.put(equalKey, "default");
        }
        System.out.println("After guarded insert: " + map.get(equalKey));

        System.out.println("Previous value: " + map.put(equalKey, "ready"));
        System.out.println("Current value: " + map.get(storedKey));
        System.out.println("Size: " + map.size());
    }
}

Resultaat

Same reference: false
Equal key: contains=true, get=null
Missing key: contains=false, get=null
After guarded insert: null
Previous value: null
Current value: ready
Size: 1

De twee `String`-objecten met de tekst `task` zijn gelijk maar hebben verschillende referenties. `get` geeft voor de aanwezige en de ontbrekende sleutel `null` terug, maar `containsKey` geeft alleen voor de aanwezige sleutel `true` terug. De voorwaarde voorkomt dat de standaardwaarde wordt ingevoegd. De onvoorwaardelijke `put` geeft de vorige waarde `null` terug en slaat `ready` op zonder de map groter te maken.

Gerelateerde lessen

  • Java · Les 17 · Gevorderd · Versie: 2
  • Java · Les 18 · Gevorderd · Versie: 2
  • Java · Les 39 · Gemiddeld · Versie: 2

Bronnen