Java HashMap: put, get, iterar y patrones comunes

Un Map almacena pares clave-valor

Un HashMap (de java.util) almacena asociaciones: cada clave se asigna a un valor, y buscas los valores por su clave en tiempo aproximadamente constante. Piensa en un diccionario: la palabra es la clave y la definición es el valor.

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        System.out.println(ages.get("Boris"));
        System.out.println(ages);
    }
}

Los dos parámetros de tipo son <KeyType, ValueType>. Aquí las claves son String y los valores son Integer. Al igual que con ArrayList, normalmente declaras la variable con el tipo de la interfaz Map y construyes un HashMap.

put, get y sobrescritura

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);
        stock.put("apples", 75);   // misma clave -> sobrescribe el valor anterior

        System.out.println(stock.get("apples"));  // 75
        System.out.println(stock.get("pears"));    // null - la clave no existe
    }
}

Dos cosas que conviene interiorizar:

• Una clave es única. put con una clave existente reemplaza su valor y devuelve el anterior.
• get sobre una clave inexistente devuelve null, no un error. Hacer el auto-unboxing de ese null a un int lanza una NullPointerException, una fuente habitual de errores.

getOrDefault evita la trampa del null

En lugar de comprobar null cada vez, pide un valor por defecto:

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);

        int apples = stock.getOrDefault("apples", 0);
        int pears = stock.getOrDefault("pears", 0);

        System.out.println(apples + " apples, " + pears + " pears");
    }
}

Esta es la forma más limpia de manejar búsquedas de elementos "tal vez presentes", y conduce directamente al patrón de HashMap más famoso.

Contar ocurrencias

Contar cuántas veces aparece cada elemento es la tarea de manual para un HashMap:

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

public class Main {
    public static void main(String[] args) {
        String text = "the cat the dog the cat";
        Map<String, Integer> counts = new HashMap<>();

        for (String word : text.split(" ")) {
            counts.put(word, counts.getOrDefault(word, 0) + 1);
        }

        System.out.println(counts);
    }
}

El patrón map.put(key, map.getOrDefault(key, 0) + 1) se lee como "toma el conteo actual (o cero), súmale uno y vuélvelo a guardar". Un equivalente más elegante es counts.merge(word, 1, Integer::sum).

Comprobar y eliminar

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        System.out.println(ages.containsKey("Ada"));     // true
        System.out.println(ages.containsValue(29));      // true
        System.out.println(ages.size());                 // 2

        ages.remove("Ada");
        System.out.println(ages.containsKey("Ada"));     // false
    }
}

putIfAbsent(key, value) solo escribe cuando la clave no existe, útil para la inicialización perezosa.

Recorrer un HashMap

El bucle más común recorre entrySet(), dándote cada clave y valor juntos:

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Si solo necesitas las claves o solo los valores:

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        for (String name : ages.keySet()) {
            System.out.println(name);
        }
        for (int age : ages.values()) {
            System.out.println(age);
        }
    }
}

También puedes usar forEach con una lambda: ages.forEach((name, age) -> System.out.println(name + ": " + age));.

El HashMap no conserva el orden

Un HashMap no garantiza ningún orden de iteración: es el que produce el hashing, y puede cambiar entre ejecuciones. Si necesitas un orden predecible:

• LinkedHashMap conserva el orden de inserción.
• TreeMap mantiene las claves ordenadas por su orden natural (o por un Comparator que proporciones).

Las tres implementan la interfaz Map, así que cambiar de una a otra es modificar una sola línea en el constructor.

Las claves deben ser hashables

HashMap encuentra las entradas haciendo hash de la clave, por lo que el hashCode() y el equals() de una clave deben ser coherentes entre sí. Los tipos integrados como String e Integer ya lo hacen correctamente. Si usas tu propia clase como clave, sobrescribe tanto equals como hashCode; de lo contrario, dos objetos que sean "iguales" en significado terminarán en cubetas distintas y tus búsquedas fallarán de forma misteriosa.

Siguiente: HashSet

Un HashMap responde a "¿qué valor está almacenado bajo esta clave?". Cuando solo te importa si algo está presente o no (un conjunto de valores únicos, sin datos asociados), la herramienta es HashSet, que viene a continuación.