WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Map-Zugriff: Schlüssel prüfen, Werte lesen und schreiben

Unterscheide fehlende Schlüssel von gespeicherten Nullwerten, wähle die passende Abfragemethode und speichere nur vollständig konstruierte Singletons im Cache.

Version: Java SE 21

Syntax

// Instance method declarations in java.util.Map<K, V>
boolean containsKey(Object key);
V get(Object key);
default V getOrDefault(Object key, V defaultValue) {
    V value = get(key);
    return (value != null || containsKey(key)) ? value : defaultValue;
}
V put(K key, V value);

In Java SE 21 prüft Map.containsKey(Object key), ob zum Schlüssel ein Eintrag existiert, auch wenn sein Wert null ist. Map.get(Object key) liefert den gespeicherten Wert oder bei fehlendem Eintrag null. Bei Maps, die Nullwerte zulassen, kann get allein diese Fälle nicht unterscheiden.

Map.getOrDefault(Object key, V defaultValue) liefert den Ersatzwert nur bei einem fehlenden Eintrag. Ist dem Schlüssel null zugeordnet, bleibt das Ergebnis null; die Abfrage fügt keinen Eintrag hinzu. In map.getOrDefault(key, factory()) wird factory() auch bei vorhandenem Eintrag ausgeführt: Java wertet die Argumente vor dem Methodenaufruf aus.

Map.put(K key, V value) fügt einen Eintrag hinzu oder ersetzt seinen Wert und liefert den vorherigen Wert zurück. null kann bedeuten, dass kein Eintrag existierte oder dass sein vorheriger Wert null war. HashMap unterstützt put und erlaubt einen Nullschlüssel sowie Nullwerte; das gilt nicht für jede Map. Wird put nicht unterstützt, folgt eine UnsupportedOperationException; ein unzulässiges null beim Schreiben führt zu einer NullPointerException. Je nach Implementierung kann ein unzulässiger Typ oder eine unzulässige Eigenschaft von Schlüssel oder Wert eine ClassCastException bzw. IllegalArgumentException auslösen. Bei Abfragen können ein falscher Schlüsseltyp oder ein unzulässiger Nullschlüssel mit ClassCastException bzw. NullPointerException abgewiesen werden.

Halte in einer Registry für einen einzelnen Thread die Fabriken vom Cache fertiger Singletons getrennt. Prüfe zuerst den Cache; fehlt der Eintrag, suche die registrierte Fabrik und rufe sie auf. Speichere die Instanz erst, wenn sie vollständig konstruiert und auf null geprüft wurde. Wirft die Fabrik eine Ausnahme, wird nichts gespeichert. Aufrufe mit demselben Schlüssel teilen eine Instanz innerhalb einer Registry, nicht global. Bei mehreren Threads muss die gesamte Abfolge aus Prüfen, Konstruieren und Speichern koordiniert werden; ein anderer Map-Typ allein macht sie nicht atomar.

Beispiele

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.function.Supplier;

public class Main {
    record Service(String name) {}

    static final class Registry {
        private final Map<String, Supplier<Service>> registrations = new HashMap<>();
        private final Map<String, Service> ready = new HashMap<>();

        Registry() {
            registrations.put("report", () -> {
                System.out.println("construct report");
                return new Service("report");
            });
        }

        Service resolve(String key) {
            if (ready.containsKey(key)) {
                return ready.get(key);
            }
            Supplier<Service> factory = registrations.get(key);
            if (factory == null) {
                throw new IllegalArgumentException("Unknown service: " + key);
            }
            Service service = Objects.requireNonNull(factory.get(), "Factory returned null");
            ready.put(key, service);
            return service;
        }
    }

    public static void main(String[] args) {
        Map<String, String> labels = new HashMap<>();
        labels.put("unset", null);
        System.out.println("containsKey: " + labels.containsKey("unset") + "/" + labels.containsKey("missing"));
        System.out.println("get: " + labels.get("unset") + "/" + labels.get("missing"));
        System.out.println("getOrDefault: " + labels.getOrDefault("unset", "fallback") + "/"
                + labels.getOrDefault("missing", "fallback"));
        labels.put("unset", "configured");
        System.out.println("put returned: " + labels.put("unset", "updated"));
        System.out.println("current value: " + labels.get("unset"));

        Registry registry = new Registry();
        Service first = registry.resolve("report");
        Service second = registry.resolve("report");
        System.out.println("same instance: " + (first == second));
    }
}

Ergebnis

containsKey: true/false
get: null/null
getOrDefault: null/fallback
put returned: configured
current value: updated
construct report
same instance: true

Die ersten drei Zeilen vergleichen einen Eintrag mit Wert `null` mit einem fehlenden Eintrag. Anschließend liefert `put` den Wert `configured` zurück, in der Map steht aber `updated`. `construct report` erscheint einmal, und `==` bestätigt, dass beide Aufrufe dieselbe Instanz liefern.

Zugehörige Lektionen

  • Java · Lektion 59 · Fortgeschritten · Version: 2

Quellen