Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Map.containsKey e Map.put: presença de uma chave e valor null

Verifica se um mapa contém uma chave, mesmo quando o valor associado é `null`. Aprende quando `put` cria ou atualiza uma entrada e como isso difere da inserção condicional.

Versão: Java SE 21

Sintaxe

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

Map.containsKey(Object key) devolve true se o mapa contiver uma entrada para a chave, sem alterar o mapa. O contrato de Map define a correspondência através de Objects.equals(key, k), em que k é a chave guardada. Num HashMap, uma chave nova mas logicamente igual corresponde à entrada existente. IdentityHashMap compara deliberadamente as referências com == em vez disso.

Num mapa que aceita valores null, como HashMap, só o teste get(key) == null não permite distinguir uma entrada em falta de uma entrada com valor null. Usa containsKey para as distinguir. containsKey pode lançar ClassCastException se o tipo da chave for inadequado, ou NullPointerException se a chave for null e o mapa não a aceitar.

Map.put(K key, V value) cria uma entrada para uma chave em falta ou substitui o valor de uma entrada existente. Devolve o valor anterior, não o novo. Um resultado null pode indicar que não havia uma entrada ou que o valor anterior era null. put é uma operação opcional: se o mapa não a suportar, uma chamada que alteraria o mapa tem de lançar UnsupportedOperationException. Se a chamada não tiver qualquer efeito no mapa, a implementação pode lançar essa exceção, mas não é obrigada a fazê-lo. As restrições aplicáveis às chaves e aos valores dependem da implementação.

Para inserir apenas quando a chave não existe e preservar um valor null já associado, usa if (!map.containsKey(key)) map.put(key, value);. Pelo contrário, putIfAbsent pode substituir um valor null existente. A verificação e a escrita, feitas separadamente, não constituem uma operação atómica em relação a outras threads.

Exemplos

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

Resultado

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

Os dois objetos `String` com o texto `task` são iguais, mas têm referências distintas. `get` devolve `null` tanto para a chave presente como para a chave em falta, mas `containsKey` só devolve `true` para a primeira. A condição impede a inserção do valor predefinido. O `put` incondicional devolve o valor anterior `null` e guarda `ready` sem aumentar o tamanho do mapa.

Lições relacionadas

  • Java · Lição 17 · Avançado · Versão: 2
  • Java · Lição 18 · Avançado · Versão: 2
  • Java · Lição 39 · Intermédio · Versão: 2

Fontes