HashMap en Java: Metodos, Ejemplos y Uso Practico

Ultima actualizacion: 14 de julio de 2026

Contenido Rapido

HashMap almacena pares clave-valor con acceso rapido O(1)
Claves unicas; valores repetidos permitidos
Metodos esenciales: put(), get(), containsKey(), remove()
No mantiene orden de insercion; usa LinkedHashMap para orden
TreeHashMap ordena claves naturalmente con complejidad O(log n)

HashMap en Java es una implementacion de la interfaz Map que almacena pares clave-valor. Permite acceso rapido a los valores mediante la clave, con complejidad O(1) en operaciones promedio de insercion y busqueda.

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 indice es simpre un número entero (int), los HashMap guardan sus valores con un indice definido por el programador cómo por ejemplo un String.

Vídeo explicativo

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

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

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

Métodos en HashMap

Put

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

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

Get

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

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

Remove

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

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

Clear

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

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

KeySet

El método keySet nos permite obtener todos las claves de nuestro HashMap como array:

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

Iterar un HashMap

Gracias al método KeySet podemos recorrer nuestro HashMap y obtener todos su valores:

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

El indice

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 de sobreescribir nuestro equals() y hashCode() en la clase Empleado para que nuestra HashMap reconozca a un objeto Empleado como un indice. Para más información puedes ver el artículo, aquí.

Inmutabilidad del indice

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:

public class IndiceHash {
    private Integer 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 IndiceHash<>();
elementos.put(key, "success");

elementos.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 HashMap está buscando en con el indice equivocado.

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

Preguntas Frecuentes

Que es un HashMap en Java?

HashMap es una clase que implementa la interfaz Map en Java. Almacena pares de valores clave-valor, donde cada clave es unica. Permite acceso rapido a los valores usando la clave como indice. No mantiene orden de insercion ni orden natural.

Como funciona internamente un HashMap?

HashMap usa una tabla hash interna para almacenar los datos. Cada clave se convierte en un indice usando una funcion hash. Si dos claves generan el mismo indice (colision), se almacenan en una lista enlazada dentro de esa posicion. A partir de Java 8, si la lista supera 8 elementos, se convierte en un arbol rojo-negro para mejorar el rendimiento.

HashMap vs TreeMap: cual elegir?

HashMap es mas rapido 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.

Como 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 foreach o un Iterator. Para Java 8+, puedes usar forEach() con una lambda: mapa.forEach((k, v) -> System.out.println(k + '=' + v)).

Que diferencias hay entre HashMap y Hashtable?

HashMap no es sincronizado (no es thread-safe), permite claves null y valores null, y es mas rapido. Hashtable es sincronizado (thread-safe), no permite nulls, y es considerado obsoleto. Usa ConcurrentHashMap si necesitas thread-safety.

Como evitar colisiones en un HashMap?

Las colisiones son inevitables en tablas hash, pero puedes minimizarlas: elige buenas funciones hash, usa un tamano inicial adecuado, especifica un load factor apropiado (default 0.75) y asegurate de que las claves implementen bien hashCode() y equals().