Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Accesso a una mappa: presenza della chiave, lettura e scrittura

Distingui una chiave assente da un valore `null` memorizzato, scegli il metodo di lettura corretto e inserisci nella cache solo singleton già costruiti.

Versione: Java SE 21

Sintassi

// 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, Map.containsKey(Object key) verifica se esiste una voce per la chiave, anche quando il suo valore è null. Map.get(Object key) restituisce il valore memorizzato, oppure null se la voce manca. Nelle mappe che ammettono valori null, get da solo non distingue i due casi.

Map.getOrDefault(Object key, V defaultValue) restituisce il valore di ripiego solo se manca la voce. Una chiave associata a null restituisce comunque null e la lettura non inserisce nulla. In map.getOrDefault(key, factory()), factory() viene eseguito anche se la chiave è presente: Java valuta gli argomenti prima di chiamare il metodo.

Map.put(K key, V value) aggiunge una voce o ne sostituisce il valore e restituisce quello precedente. Un risultato null può indicare che la voce mancava o che il valore precedente era null. HashMap supporta put e ammette una chiave null e valori null, ma non tutte le mappe lo fanno. Se put non è supportato, viene lanciata UnsupportedOperationException; se si scrive un null non ammesso, viene lanciata NullPointerException. A seconda dell’implementazione, un tipo o una proprietà non ammessi della chiave o del valore possono causare rispettivamente ClassCastException o IllegalArgumentException. Una lettura può rifiutare una chiave di tipo errato con ClassCastException o una chiave null non ammessa con NullPointerException.

In un registro usato da un solo thread, tieni separate le factory dalla cache dei singleton pronti. Controlla prima la cache; se la voce manca, cerca e invoca la factory registrata. Inserisci l’istanza nella cache solo dopo averla costruita completamente e verificato che non sia null. Se la factory lancia un’eccezione, non viene memorizzato nulla. Le chiamate con la stessa chiave condividono un’istanza all’interno di un registro, non a livello globale. Con più thread, coordina l’intera sequenza di controllo, costruzione e scrittura: cambiare solo il tipo di mappa non rende atomica la sequenza.

Esempi

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

Risultato

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

Le prime tre righe confrontano una voce con valore `null` e una voce assente. Poi `put` restituisce `configured`, ma lascia `updated` nella mappa. Il messaggio `construct report` compare una sola volta e `==` conferma che entrambe le chiamate restituiscono la stessa istanza.

Lezioni correlate

  • Java · Lezione 59 · Avanzato · Versione: 2

Fonti