CKTIS / Java
Map-toegang: sleutels controleren, waarden lezen en schrijven
Maak onderscheid tussen een ontbrekende sleutel en een opgeslagen `null`, kies de juiste opzoekmethode en cache alleen volledig geconstrueerde singletons.
Versie: 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 controleert Map.containsKey(Object key) of er een item voor de sleutel bestaat, ook als de waarde null is. Map.get(Object key) geeft de opgeslagen waarde terug, of null als er geen item is. Bij maps die null als waarde toestaan, kun je deze twee gevallen niet met alleen get onderscheiden.
Map.getOrDefault(Object key, V defaultValue) geeft de terugvalwaarde alleen terug als er geen item voor de sleutel bestaat. Een sleutel met waarde null levert nog steeds null op, en het opzoeken voegt niets toe. In map.getOrDefault(key, factory()) wordt factory() ook bij een bestaande sleutel uitgevoerd: Java evalueert argumenten voordat de methode wordt aangeroepen.
Map.put(K key, V value) voegt een item toe of vervangt de waarde ervan en geeft de vorige waarde terug. Een resultaat van null kan betekenen dat het item ontbrak of dat de vorige waarde null was. HashMap ondersteunt put en staat een null-sleutel en null-waarden toe; niet elke map doet dat. Als put niet wordt ondersteund, volgt UnsupportedOperationException; het opslaan van een niet-toegestane null veroorzaakt NullPointerException. Afhankelijk van de implementatie kan een niet-toegestaan type of kenmerk van een sleutel of waarde respectievelijk ClassCastException of IllegalArgumentException veroorzaken. Bij het opzoeken kan een sleutel van het verkeerde type worden geweigerd met ClassCastException, en een niet-toegestane null-sleutel met NullPointerException.
Houd in een register dat door één thread wordt gebruikt de fabrieken apart van de cache met gebruiksklare singletons. Controleer eerst de cache; ontbreekt het item, zoek dan de geregistreerde fabriek op en roep die aan. Cache de instantie pas nadat ze volledig is geconstrueerd en je hebt gecontroleerd dat ze niet null is. Als de fabriek een uitzondering gooit, wordt niets gecachet. Aanroepen met dezelfde sleutel delen een instantie binnen één register, niet globaal. Coördineer bij meerdere threads de volledige reeks van controleren, construeren en opslaan: alleen het maptype wijzigen maakt die reeks niet atomair.
Voorbeelden
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));
}
}Resultaat
containsKey: true/false get: null/null getOrDefault: null/fallback put returned: configured current value: updated construct report same instance: true
De eerste drie regels vergelijken een item met waarde `null` met een ontbrekend item. Daarna geeft `put` de waarde `configured` terug, maar blijft `updated` in de map staan. `construct report` verschijnt één keer, en `==` bevestigt dat beide aanroepen dezelfde instantie teruggeven.
Gerelateerde lessen
- Java · Les 59 · Gevorderd · Versie: 2