Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Dostęp do mapy: obecność klucza, odczyt i zapis

Odróżniaj brak klucza od wartości `null`, dobieraj wartość domyślną do odczytu i zapisuj w pamięci podręcznej tylko w pełni skonstruowane singletony.

Wersja: Java SE 21

Składnia

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

W Java SE 21 Map.containsKey(Object key) sprawdza, czy dla klucza istnieje wpis, nawet jeśli jego wartość to null. Map.get(Object key) zwraca przypisaną wartość albo null, gdy wpisu nie ma. Jeżeli mapa dopuszcza wartości null, sam wynik get nie odróżnia tych dwóch przypadków.

Map.getOrDefault(Object key, V defaultValue) zwraca wartość domyślną tylko wtedy, gdy klucza nie ma w mapie. Istniejący wpis z null nadal daje null, a odczyt nie dodaje wpisu do mapy. W wywołaniu map.getOrDefault(key, factory()) metoda factory() jest wywoływana nawet wtedy, gdy klucz istnieje: Java oblicza argumenty przed wywołaniem metody.

Map.put(K key, V value) dodaje wpis albo zastępuje jego wartość i zwraca poprzednią wartość. Wynik null oznacza brak poprzedniego wpisu albo jego poprzednią wartość null. HashMap obsługuje put i dopuszcza klucz oraz wartości null, ale nie każda mapa na to pozwala. Brak obsługi zapisu oznacza UnsupportedOperationException, a niedozwolony null przy zapisie powoduje NullPointerException. Zależnie od implementacji niedozwolony typ lub cecha klucza bądź wartości może spowodować odpowiednio ClassCastException lub IllegalArgumentException. Odczyt może odrzucić klucz niewłaściwego typu przez ClassCastException albo niedozwolony klucz null przez NullPointerException.

W rejestrze działającym w jednym wątku trzymaj fabryki oddzielnie od mapy gotowych singletonów. Najpierw sprawdź pamięć podręczną; jeśli nie ma wpisu, pobierz z rejestru fabrykę i wywołaj ją. Zapisz instancję dopiero po pełnym skonstruowaniu i sprawdzeniu, że nie jest null. Jeśli fabryka zgłosi wyjątek, nic nie trafia do pamięci podręcznej. Instancja jest współdzielona przez wywołania dla danego klucza w obrębie jednego rejestru, nie globalnie. W wielu wątkach sekwencja sprawdzenia, konstrukcji i zapisu wymaga koordynacji; sama zmiana typu mapy nie czyni tej sekwencji atomową.

Przykłady

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

Wynik

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

Pierwsze trzy wiersze porównują wpis z wartością `null` z brakiem wpisu. Następnie `put` zwraca `configured`, ale w mapie zostaje `updated`. Komunikat `construct report` pojawia się raz, a `==` potwierdza, że oba odczyty zwracają tę samą instancję.

Powiązane lekcje

  • Java · Lekcja 59 · Zaawansowany · Wersja: 2

Źródła