Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Accès à une Map : présence d’une clé, lecture et écriture

Distinguez une clé absente d’une valeur `null` stockée, choisissez la bonne méthode de lecture et ne mettez en cache que des singletons entièrement construits.

Version : Java SE 21

Syntaxe

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

Dans Java SE 21, Map.containsKey(Object key) vérifie si une entrée existe pour la clé, même si sa valeur est null. Map.get(Object key) renvoie la valeur stockée, ou null si l’entrée est absente. Si la map accepte les valeurs null, get seul ne permet pas de distinguer ces deux cas.

Map.getOrDefault(Object key, V defaultValue) renvoie la valeur de repli uniquement si la clé n’a pas d’entrée. Une clé associée à null donne toujours null, et la lecture n’insère rien. Dans map.getOrDefault(key, factory()), factory() s’exécute même si la clé est présente : Java évalue les arguments avant d’appeler la méthode.

Map.put(K key, V value) ajoute une entrée ou remplace sa valeur et renvoie la valeur précédente. Un résultat null peut indiquer une entrée absente ou une ancienne valeur null. HashMap prend en charge put et accepte une clé null et des valeurs null, mais ce n’est pas le cas de toutes les maps. Une opération put non prise en charge lève UnsupportedOperationException, et l’écriture d’un null interdit lève NullPointerException. Selon l’implémentation, un type ou une propriété interdite de la clé ou de la valeur peut déclencher respectivement ClassCastException ou IllegalArgumentException. Une lecture peut rejeter une clé de type incompatible avec ClassCastException ou une clé null interdite avec NullPointerException.

Dans un registre utilisé par un seul thread, séparez les fabriques du cache des singletons prêts à l’emploi. Consultez d’abord le cache ; en l’absence d’entrée, cherchez la fabrique enregistrée et appelez-la. Mettez l’instance en cache seulement après sa construction complète et après avoir vérifié qu’elle n’est pas null. Si la fabrique lève une exception, rien n’est mis en cache. Les appels avec la même clé partagent une instance dans un registre donné, pas globalement. Avec plusieurs threads, coordonnez toute la séquence de vérification, de construction et d’écriture : changer seulement le type de map ne rend pas cette séquence atomique.

Exemples

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

Résultat

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

Les trois premières lignes comparent une entrée de valeur `null` et une entrée absente. Ensuite, `put` renvoie `configured`, mais la map contient `updated`. Le message `construct report` apparaît une fois, et `==` confirme que les deux appels renvoient la même instance.

Leçons associées

  • Java · Leçon 59 · Avancé · Version : 2

Sources