Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Acceso a un mapa: presencia de claves, lectura y escritura

Distingue una clave ausente de un valor `null` almacenado, elige el método de consulta adecuado y guarda en caché solo singletons completamente construidos.

Versión: Java SE 21

Sintaxis

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

En Java SE 21, Map.containsKey(Object key) comprueba si existe una entrada para la clave, aunque su valor sea null. Map.get(Object key) devuelve el valor almacenado o null si no hay entrada. Si el mapa admite valores null, get por sí solo no distingue estos dos casos.

Map.getOrDefault(Object key, V defaultValue) devuelve el valor alternativo solo cuando la clave no tiene entrada. Una clave asociada a null sigue devolviendo null, y la consulta no inserta nada. En map.getOrDefault(key, factory()), factory() se ejecuta aunque exista la clave: Java evalúa los argumentos antes de llamar al método.

Map.put(K key, V value) añade una entrada o reemplaza su valor y devuelve el valor anterior. Un resultado null puede indicar que no había entrada o que su valor anterior era null. HashMap admite put, una clave null y valores null, pero no todos los mapas lo permiten. Si put no está soportado, se lanza UnsupportedOperationException; si se escribe un null no permitido, se lanza NullPointerException. Según la implementación, un tipo o una propiedad no admitidos de la clave o del valor pueden causar, respectivamente, ClassCastException o IllegalArgumentException. Una consulta puede rechazar una clave de tipo incorrecto con ClassCastException o una clave null no admitida con NullPointerException.

En un registro de un solo hilo, mantén las fábricas separadas de la caché de singletons listos. Consulta primero la caché; si no hay entrada, busca la fábrica registrada e invócala. Guarda la instancia solo cuando esté completamente construida y hayas comprobado que no sea null. Si la fábrica lanza una excepción, no se guarda nada. Las llamadas con la misma clave comparten una instancia dentro de un registro, no globalmente. Con varios hilos, coordina toda la secuencia de comprobación, construcción y escritura: cambiar solo el tipo de mapa no hace atómica esa secuencia.

Ejemplos

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

Las tres primeras líneas comparan una entrada con valor `null` y una entrada ausente. Después, `put` devuelve `configured`, pero deja `updated` en el mapa. El mensaje `construct report` aparece una sola vez y `==` confirma que ambas llamadas devuelven la misma instancia.

Lecciones relacionadas

  • Java · Lección 59 · Avanzado · Versión: 2

Fuentes