HashMap en Java: métodos, ejemplos y uso práctico

Un HashMap en Java es una implementación de la interfaz Map que almacena pares clave-valor y permite acceso rápido a los valores mediante la clave. Ofrece complejidad O(1) en operaciones promedio de inserción y búsqueda. No mantiene orden de inserción ni orden natural; las claves deben implementar bien equals() y hashCode().

Última actualización: agosto 2026

Contenido Rápido

• HashMap almacena pares clave-valor con acceso rápido O(1)
• Claves únicas; valores repetidos permitidos
• Métodos esenciales: put(), get(), containsKey(), remove()
• No mantiene orden de inserción; usa LinkedHashMap para orden
• TreeMap ordena claves naturalmente con complejidad O(log n)

Un HashMap (o Map en Java) es un mapeo de clave-valor, lo que significa que cada clave se asigna exactamente a un valor y que podemos usar la clave para recuperar el valor correspondiente de un HashMap. A diferencia de las colecciones, que guardan los valores de forma ordenada y cuyo índice es siempre un número entero (int), los HashMap guardan sus valores con un índice definido por el programador, como por ejemplo un String.

Crear un HashMap

La forma más fácil de crear un HashMap es usando su constructor con los genéricos definidos:

HashMap<String, Empleado> empleadosPorNombre = new HashMap<>();

Pon en práctica lo aprendido y experimenta con HashMap en el Java Playground de CodeJa, con ejecución de código en el navegador.

Aunque también podremos usar la interfaz Map para inicializar nuestro objeto:

Map<String, Empleado> empleadosPorNombre = new HashMap<>();

Métodos en HashMap

Put

El método put nos permite agregar valores dependiendo de un índice a nuestro HashMap:

Map<String, Empleado> empleadosPorNombre = new HashMap<>();
empleadosPorNombre.put("Juan", new Empleado());

Get

El método get nos permite obtener valores dependiendo de un índice a nuestro HashMap:

Map<String, Empleado> empleadosPorNombre = new HashMap<>();
Empleado empleadoJuan = empleadosPorNombre.get("Juan");

Remove

El método remove nos permite eliminar valores dependiendo de un índice a nuestro HashMap:

Map<String, Empleado> empleadosPorNombre = new HashMap<>();
empleadosPorNombre.remove("Juan");

Clear

El método clear nos permite borrar todo nuestro HashMap:

Map<String, Empleado> empleadosPorNombre = new HashMap<>();
empleadosPorNombre.clear();

KeySet

El método keySet nos permite obtener todas las claves de nuestro HashMap como un conjunto:

Map<String, Empleado> empleadosPorNombre = new HashMap<>();
Set<String> claves = empleadosPorNombre.keySet();

Iterar un HashMap

Gracias al método keySet podemos recorrer nuestro HashMap y obtener todos sus valores:

for (String clave : empleadosPorNombre.keySet()) {
    Empleado empleado = empleadosPorNombre.get(clave);
}

El índice

Podemos usar cualquier clase como clave en nuestro HashMap. Sin embargo, para que el mapa funcione correctamente, debemos proporcionar una implementación para equals() y hashCode(). Digamos que queremos tener un mapa con el empleado como clave y el salario como valor:

HashMap<Empleado, Integer> salarioPorEmpleado = new HashMap<>();
salarioPorEmpleado.put(empleadoJuan, 5000);

Deberemos sobrescribir nuestros equals() y hashCode() en la clase Empleado para que nuestro HashMap reconozca a un objeto Empleado como un índice. Para más información, consulta el artículo sobre equals y hashCode en Java.

Inmutabilidad del índice

En la mayoría de los casos, deberíamos usar claves inmutables. O al menos, debemos ser conscientes de las consecuencias de utilizar claves mutables.

Veamos qué sucede cuando nuestra clave cambia después de que la usamos para almacenar un valor en un mapa.

Para este ejemplo, crearemos IndiceHash:

import java.util.Objects;

public class IndiceHash {
    private Integer indice;

    public IndiceHash(Integer indice) {
        this.indice = indice;
    }

    public void setIndice(Integer indice) {
        this.indice = indice;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        IndiceHash that = (IndiceHash) o;
        return Objects.equals(indice, that.indice);
    }

    @Override
    public int hashCode() {
        return Objects.hash(indice);
    }
}

Y esta es la lógica:

IndiceHash clave = new IndiceHash(1);

Map<IndiceHash, String> elementos = new HashMap<>();
elementos.put(clave, "success");

clave.setIndice(2);

System.out.println(elementos.get(clave));

Como podemos ver, ya no podemos obtener el valor correspondiente una vez que la clave ha cambiado; en su lugar, se devuelve null. Esto se debe a que el HashMap está buscando con el índice equivocado.

El caso de prueba anterior puede ser sorprendente si no tenemos una buena comprensión de cómo funciona internamente el HashMap.

HashMap vs TreeMap vs Hashtable

A la hora de elegir una implementación de Map, estas son las diferencias principales:

Preguntas Frecuentes

¿Qué es un HashMap en Java?

Un HashMap es una clase que implementa la interfaz Map en Java. Almacena pares clave-valor, donde cada clave es única. Permite acceso rápido a los valores usando la clave como índice. No mantiene orden de inserción ni orden natural.

¿Cómo funciona internamente un HashMap?

Un HashMap usa una tabla hash interna para almacenar los datos. Cada clave se convierte en un índice usando una función hash. Si dos claves generan el mismo índice (colisión), se almacenan en una lista enlazada dentro de esa posición. A partir de Java 8, si la lista supera 8 elementos, se convierte en un árbol rojo-negro para mejorar el rendimiento.

¿HashMap vs TreeMap: cuál elegir?

HashMap es más rápido para operaciones get y put (O(1) promedio) pero no mantiene orden. TreeMap ordena las claves naturalmente (O(log n)) y es mejor cuando necesitas iterar en orden o buscar rangos. Elige HashMap para velocidad y TreeMap para orden.

¿Cómo iterar un HashMap en Java?

Puedes iterar un HashMap usando entrySet() para recorrer pares clave-valor, keySet() para solo claves, o values() para solo valores. Usa un for-each o un Iterator. Para Java 8+, puedes usar forEach() con una lambda: mapa.forEach((k, v) -> System.out.println(k + "=" + v)).

¿Qué diferencias hay entre HashMap y Hashtable?

HashMap no es sincronizado (no es thread-safe), permite claves null y valores null, y es más rápido. Hashtable es sincronizado (thread-safe), no permite nulls, y es considerado obsoleto. Usa ConcurrentHashMap si necesitas thread-safety.

¿Cómo evitar colisiones en un HashMap?

Las colisiones son inevitables en tablas hash, pero puedes minimizarlas: elige buenas funciones hash, usa un tamaño inicial adecuado, especifica un load factor apropiado (por defecto 0.75) y asegúrate de que las claves implementen bien hashCode() y equals().

Artículos Relacionados

• Diferencia entre Integer e int en Java: guía completa
• Qué es un POJO en Java: definición y ejemplos
• Equals y hashCode en Java: reglas y ejemplos prácticos