WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Map.containsKey und Map.put: vorhandener Schlüssel oder null-Wert

Prüfe, ob eine Map einen Schlüssel enthält, auch wenn ihm `null` zugeordnet ist. Erfahre, wie `put` einen Eintrag anlegt oder dessen Wert ersetzt und was bedingtes Einfügen davon unterscheidet.

Version: 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) gibt true zurück, wenn die Map einen Eintrag für den Schlüssel enthält, ohne die Map zu ändern. Der Vertrag von Map definiert die Übereinstimmung über Objects.equals(key, k), wobei k der gespeicherte Schlüssel ist. In einer HashMap findet ein neuer, logisch gleicher Schlüssel den vorhandenen Eintrag. IdentityHashMap vergleicht dagegen absichtlich Referenzen mit ==.

Erlaubt eine Map null-Werte wie HashMap, unterscheidet get(key) == null allein nicht zwischen einem fehlenden Eintrag und einem Eintrag mit dem Wert null. Nutze dafür containsKey. Bei einem ungeeigneten Schlüsseltyp kann containsKey eine ClassCastException auslösen, bei einem unzulässigen null-Schlüssel eine NullPointerException.

Map.put(K key, V value) legt für einen fehlenden Schlüssel einen Eintrag an oder ersetzt den Wert eines bestehenden Eintrags. Die Methode gibt den alten Wert zurück, nicht den neuen. Das Ergebnis null kann bedeuten, dass kein Eintrag vorhanden war oder dass sein bisheriger Wert null war. put ist optional: Unterstützt eine Map diese Operation nicht, muss ein Aufruf, der die Map ändern würde, eine UnsupportedOperationException auslösen. Hätte der Aufruf keine Auswirkung auf die Map, kann die Implementierung diese Ausnahme auslösen, muss es aber nicht. Welche Schlüssel und Werte zulässig sind, hängt von der Implementierung ab.

Mit if (!map.containsKey(key)) map.put(key, value); fügst du nur bei fehlendem Schlüssel ein und behältst einen vorhandenen null-Wert bei. putIfAbsent kann dagegen einen vorhandenen null-Wert ersetzen. Die getrennte Prüfung und das anschließende Schreiben bilden gegenüber anderen Threads keine atomare Operation.

Beispiele

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

Ergebnis

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

Die beiden `String`-Objekte mit dem Text `task` sind gleich, aber ihre Referenzen sind verschieden. `get` liefert für den vorhandenen und den fehlenden Schlüssel `null`, doch nur beim vorhandenen liefert `containsKey` den Wert `true`. Die Bedingung verhindert das Einfügen des Standardwerts. Das bedingungslose `put` gibt den bisherigen Wert `null` zurück und speichert `ready`, ohne die Größe der Map zu erhöhen.

Zugehörige Lektionen

  • Java · Lektion 17 · Fortgeschritten · Version: 2
  • Java · Lektion 18 · Fortgeschritten · Version: 2
  • Java · Lektion 39 · Mittlere Stufe · Version: 2

Quellen