En este post te mostraré algunas operaciones básicas para el manejo de HashMap en Java; por ejemplo, veremos cómo agregar elementos, eliminar elementos, recorrer el hasmap, saber si tiene determinado elemento y obtener un elemento.

Para recorrer el hashmap vamos a usar un foreach; y para las otras operaciones usaremos los métodos remove,  containsKey, containsValue, put y get.

¿Para qué sirven los mapas?

Un mapa es una estructura de datos que tiene claves y valores; la ventaja que ofrece es que su acceso es más rápido, a diferencia de un arreglo.

Es decir, para obtener un elemento basta con conocer su clave, no hay que recorrer toda la estructura para buscarlo.

En Java, un mapa puede tener una clave y valor genéricos, es decir, de cualquier tipo.

HashMap en Java

Para usar esta estructura necesitamos primero importarla:

import java.util.HashMap;

Después, podemos crear un mapa así:

HashMap<K, V> hashmap = new HashMap<>();

En donde K es el tipo de dato de las claves, y V el tipo de dato del valor. En este caso vamos a usar el mapa para contar las veces que aparece una vocal en un texto (para un tutorial que estoy preparando) así que será de tipo String, Integer así:

HashMap<String, Integer> hashMap = new HashMap<>();

Agregar elemento con put

Podemos agregar un elemento al mapa. Si ya existe, será remplazado. En este caso sería:

hashMap.put("A", 1);

Este método devuelve el valor anterior que estaba en esa clave, o null.

Saber si hashmap en Java tiene elemento

Para esto podemos usar containsKey o containsValue. Ambos regresan un booleano. Por ejemplo:

hashMap.put("A", 1);
if (hashMap.containsKey("A")) {
    System.out.printf("Contiene la clave A. Su valor es: %d\n", hashMap.get("A"));
}
if (hashMap.containsValue(0)) {
    System.out.println("Contiene el valor 0");
}

Como se puede observar, el método containsValue funciona para saber si el mapa tiene un valor, aunque no nos dice en dónde se encuentra.

Obtener elemento

Antes de obtener un elemento recomiendo comprobar su existencia con containsKey como se mostró anteriormente.

Para obtener el valor se invoca al método get. En este caso sería:

int aparicionesDeA = hashMap.get("A");

En caso de que el elemento con esa clave no exista, el método devolverá null.

Eliminar elemento

Para eliminar un elemento del Hashmap en Java invocamos a remove, con la clave. Así:

hashMap.remove("A");

Recorrer Hashmap en Java

Finalmente veamos cómo obtener cada clave y valor del mapa; es decir, recorrerlo. Hay varias estrategias pero yo lo haré con un simple foreach.

// Ahora ponemos varios elementos para imprimirlos
hashMap.put("A", 1);
hashMap.put("E", 12);
hashMap.put("I", 15);
hashMap.put("O", 0);
hashMap.put("U", 0);
for (HashMap.Entry<String, Integer> entry : hashMap.entrySet()) {
    System.out.printf("Clave: %s. Valor: %d\n", entry.getKey(), entry.getValue());
}

Lo importante aquí es que en cada paso podemos obtener la clave con entry.getKey y el valor con entry.getValue.

Poniendo todo junto

Finalmente veamos el código Java en conjunto:

/*
 * Archivo: EjemploHashMap.java
 * Clase: EjemploHashMap
 * Autor: parzibyte
 * Fecha: 1/7/20 9:03 PM
 * Visita https://parzibyte.me/blog para más tutoriales sobre Java
 */
import java.util.HashMap;

public class EjemploHashMap {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("A", 1);
        if (hashMap.containsKey("A")) {
            System.out.printf("Contiene la clave A. Su valor es: %d\n", hashMap.get("A"));
        }

        if (hashMap.containsValue(0)) {
            System.out.println("Contiene el valor 0");
        }

        int aparicionesDeA = hashMap.get("A");
        hashMap.remove("A");

        // Ahora ponemos varios elementos para imprimirlos
        hashMap.put("A", 1);
        hashMap.put("E", 12);
        hashMap.put("I", 15);
        hashMap.put("O", 0);
        hashMap.put("U", 0);
        for (HashMap.Entry<String, Integer> entry : hashMap.entrySet()) {
            System.out.printf("Clave: %s. Valor: %d\n", entry.getKey(), entry.getValue());
        }
    }
}

La salida en mi caso es:

Conclusión

Además de los métodos que expuse, existen otros interesantes; por ahora puedo mencionar al método clear que limpia el mapa.

Te invito a ver mis otros artículos sobre Java.