CKTIS / Java
Acesso a um mapa: presença da chave, leitura e escrita
Distingue uma chave ausente de um valor `null` guardado, escolhe o método de consulta adequado e guarda na cache apenas singletons completamente construídos.
Versão: Java SE 21
Sintaxe
// 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);Em Java SE 21, Map.containsKey(Object key) verifica se existe uma entrada para a chave, mesmo que o valor seja null. Map.get(Object key) devolve o valor guardado, ou null se não houver entrada. Nos mapas que aceitam valores null, get por si só não distingue os dois casos.
Map.getOrDefault(Object key, V defaultValue) devolve o valor alternativo apenas quando não existe uma entrada para a chave. Uma chave associada a null continua a devolver null, e a consulta não insere nada. Em map.getOrDefault(key, factory()), factory() é executado mesmo que a chave esteja presente: Java avalia os argumentos antes de invocar o método.
Map.put(K key, V value) adiciona uma entrada ou substitui o seu valor e devolve o valor anterior. Um resultado null pode indicar que não havia entrada ou que o valor anterior era null. HashMap suporta put e aceita uma chave null e valores null, mas nem todos os mapas o permitem. Uma operação put não suportada lança UnsupportedOperationException; escrever um null não permitido lança NullPointerException. Consoante a implementação, um tipo ou uma propriedade não permitidos da chave ou do valor podem causar, respetivamente, ClassCastException ou IllegalArgumentException. Uma consulta pode rejeitar uma chave de tipo incorreto com ClassCastException ou uma chave null não permitida com NullPointerException.
Num registo utilizado por um único thread, mantém as fábricas separadas da cache dos singletons prontos a usar. Consulta primeiro a cache; se não houver entrada, procura e invoca a fábrica registada. Guarda a instância na cache apenas quando estiver completamente construída e tiveres verificado que não é null. Se a fábrica lançar uma exceção, nada é guardado na cache. As chamadas com a mesma chave partilham uma instância dentro de um registo, não globalmente. Com vários threads, coordena toda a sequência de verificação, construção e escrita: mudar apenas o tipo de mapa não torna esta sequência atómica.
Exemplos
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));
}
}Resultado
containsKey: true/false get: null/null getOrDefault: null/fallback put returned: configured current value: updated construct report same instance: true
As primeiras três linhas comparam uma entrada com valor `null` com uma entrada ausente. Em seguida, `put` devolve `configured`, mas deixa `updated` no mapa. A mensagem `construct report` aparece uma vez, e `==` confirma que ambas as chamadas devolvem a mesma instância.
Lições relacionadas
- Java · Lição 59 · Avançado · Versão: 2