Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Map.containsKey e Map.put: presenza della chiave e valore null

Verifica se una chiave è presente nella mappa anche quando il suo valore è `null`. Scopri quando `put` aggiunge una voce, quando ne sostituisce il valore e come si distingue dall’inserimento condizionale.

Versione: Java SE 21

Sintassi

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

Map.containsKey(Object key) restituisce true se la mappa contiene una voce per la chiave, senza modificare la mappa. Il contratto di Map definisce la corrispondenza tramite Objects.equals(key, k), dove k è la chiave memorizzata. In una HashMap, una chiave nuova ma logicamente uguale corrisponde alla voce esistente. IdentityHashMap confronta invece deliberatamente i riferimenti con ==.

In una mappa che ammette valori null, come HashMap, il solo test get(key) == null non distingue una voce assente da una con valore null. Usa containsKey per distinguerle. containsKey può lanciare ClassCastException per un tipo di chiave non adatto oppure NullPointerException se la chiave è null e la mappa non la ammette.

Map.put(K key, V value) crea una voce per una chiave assente o sostituisce il valore di una voce esistente. Restituisce il valore precedente, non quello nuovo. Un risultato null può significare che non c’era alcuna voce o che il suo valore precedente era null. put è un’operazione facoltativa: se la mappa non la supporta, una chiamata che modificherebbe la mappa deve lanciare UnsupportedOperationException. Se la chiamata non avesse alcun effetto sulla mappa, l’implementazione può lanciare l’eccezione, ma non è tenuta a farlo. Le restrizioni su chiavi e valori dipendono dall’implementazione.

Per inserire solo se la chiave è assente e conservare un valore null esistente, usa if (!map.containsKey(key)) map.put(key, value);. putIfAbsent, invece, può sostituire un valore null esistente. Il controllo e la scrittura separati non costituiscono un’operazione atomica rispetto agli altri thread.

Esempi

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

Risultato

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

I due oggetti `String` che contengono `task` sono uguali, ma hanno riferimenti distinti. `get` restituisce `null` sia per la chiave presente sia per quella assente, mentre `containsKey` restituisce `true` solo per la prima. La condizione impedisce l’inserimento del valore predefinito. Il `put` incondizionato restituisce il valore precedente `null` e memorizza `ready` senza aumentare la dimensione della mappa.

Lezioni correlate

  • Java · Lezione 17 · Avanzato · Versione: 2
  • Java · Lezione 18 · Avanzato · Versione: 2
  • Java · Lezione 39 · Intermedio · Versione: 2

Fonti