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

CKTIS / Java

Map.containsKey y Map.put: presencia de una clave frente a un valor null

Comprueba si una clave está presente en un mapa aunque su valor sea `null`. Aprende cómo `put` inserta una entrada o sustituye su valor y en qué se diferencia de una inserción condicional.

Versión: Java SE 21

Sintaxis

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

Map.containsKey(Object key) devuelve true si el mapa contiene una entrada para la clave, sin modificar el mapa. El contrato de Map define la coincidencia mediante Objects.equals(key, k), donde k es la clave almacenada. En un HashMap, una clave nueva pero lógicamente igual coincide con la entrada existente. IdentityHashMap, en cambio, compara deliberadamente las referencias con ==.

En un mapa que admite valores null, como HashMap, get(key) == null por sí solo no distingue una entrada ausente de una entrada con valor null. Usa containsKey para distinguirlas. containsKey puede lanzar ClassCastException si el tipo de la clave no es adecuado, o NullPointerException si la clave es null y el mapa no la admite.

Map.put(K key, V value) crea una entrada para una clave ausente o sustituye el valor de una entrada existente. Devuelve el valor anterior, no el nuevo. Un resultado null puede indicar que no había entrada o que su valor anterior era null. put es opcional: si el mapa no lo admite, una llamada que modificaría el mapa debe lanzar UnsupportedOperationException. Si la llamada no tuviera ningún efecto sobre el mapa, la implementación puede lanzar esa excepción, pero no está obligada a hacerlo. Las restricciones sobre claves y valores dependen de la implementación.

Para insertar solo si falta la clave y conservar un valor null existente, usa if (!map.containsKey(key)) map.put(key, value);. En cambio, putIfAbsent puede sustituir un valor null existente. La comprobación y la escritura por separado no forman una operación atómica con respecto a otros hilos.

Ejemplos

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

Los dos objetos `String` que contienen `task` son iguales, pero sus referencias son distintas. `get` devuelve `null` para ambas claves, pero `containsKey` solo devuelve `true` para la presente. La condición evita insertar el valor predeterminado. El `put` incondicional devuelve el `null` anterior y guarda `ready` sin aumentar el tamaño del mapa.

Lecciones relacionadas

  • Java · Lección 17 · Avanzado · Versión: 2
  • Java · Lección 18 · Avanzado · Versión: 2
  • Java · Lección 39 · Intermedio · Versión: 2

Fuentes