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

CKTIS / Java

Map.containsKey et Map.put : présence d’une clé et valeur null

Vérifiez si une clé est présente dans une map, même si sa valeur est `null`. Découvrez comment `put` ajoute une entrée ou remplace sa valeur, et en quoi cela diffère d’une insertion conditionnelle.

Version : Java SE 21

Syntaxe

java.util.Map<K, V> — instance method signatures:
boolean containsKey(Object key)
V put(K key, V value)

Map.containsKey(Object key) renvoie true si la map contient une entrée pour la clé, sans modifier la map. Le contrat de Map définit la correspondance par Objects.equals(key, k), où k est la clé stockée. Dans une HashMap, une nouvelle clé logiquement égale retrouve l’entrée existante. IdentityHashMap compare au contraire les références avec ==, par choix de conception.

Dans une map qui accepte les valeurs null, comme HashMap, le seul test get(key) == null ne distingue pas une entrée absente d’une entrée de valeur null. Utilisez containsKey pour les distinguer. containsKey peut lever une ClassCastException si le type de la clé ne convient pas, ou une NullPointerException si la clé est null et que la map ne l’accepte pas.

Map.put(K key, V value) crée une entrée si la clé est absente ou remplace la valeur de l’entrée existante. La méthode renvoie l’ancienne valeur, pas la nouvelle. Un résultat null peut indiquer une absence d’entrée précédente ou une ancienne valeur null. put est une opération facultative : si une map ne la prend pas en charge, un appel qui modifierait la map doit lever une UnsupportedOperationException. Si l’appel n’aurait aucun effet sur la map, l’implémentation peut lever cette exception, mais n’y est pas tenue. Les restrictions sur les clés et les valeurs dépendent de l’implémentation.

Pour insérer uniquement si la clé est absente et conserver une valeur null existante, utilisez if (!map.containsKey(key)) map.put(key, value);. À l’inverse, putIfAbsent peut remplacer une valeur null existante. La vérification et l’écriture séparées ne constituent pas une opération atomique vis-à-vis des autres threads.

Exemples

import java.util.HashMap;
import java.util.Map;

public class MapContainsKeyDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        String storedKey = new String("task");
        String equalKey = new String("task");
        String missingKey = "other";

        map.put(storedKey, null);

        System.out.println("Same reference: " + (storedKey == equalKey));
        System.out.println("Equal key: contains=" + map.containsKey(equalKey)
                + ", get=" + map.get(equalKey));
        System.out.println("Missing key: contains=" + map.containsKey(missingKey)
                + ", get=" + map.get(missingKey));

        if (!map.containsKey(equalKey)) {
            map.put(equalKey, "default");
        }
        System.out.println("After guarded insert: " + map.get(equalKey));

        System.out.println("Previous value: " + map.put(equalKey, "ready"));
        System.out.println("Current value: " + map.get(storedKey));
        System.out.println("Size: " + map.size());
    }
}

Résultat

Same reference: false
Equal key: contains=true, get=null
Missing key: contains=false, get=null
After guarded insert: null
Previous value: null
Current value: ready
Size: 1

Les deux objets `String` qui contiennent `task` sont égaux mais ont des références distinctes. `get` renvoie `null` pour la clé présente comme pour la clé absente, mais `containsKey` ne renvoie `true` que pour la clé présente. La condition empêche l’insertion de la valeur par défaut. L’appel inconditionnel à `put` renvoie l’ancienne valeur `null` et stocke `ready` sans augmenter la taille de la map.

Leçons associées

  • Java · Leçon 17 · Avancé · Version : 2
  • Java · Leçon 18 · Avancé · Version : 2
  • Java · Leçon 39 · Intermédiaire · Version : 2

Sources