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