Cómo crear y usar un HashMap en tus programas Java

No hay una mejor manera de explicarte los HashMap en Java que con la analogía del diccionario. Piensa que las palabras son las claves y las definiciones son los valores y lo único que tienes que hacer es aplicarlo a la programación. ¿Cómo? Pues en la programación almacenarías pares clave-valor, como precios de productos o configuraciones avanzadas con objetos como claves.

¿Qué es un HashMap?

Un HashMap en Java es una colección que almacena datos en pares de clave y valor. Lo que implica que cada clave única está asociada a un valor, y puedes usar la clave para recuperar su valor correspondiente.

Ojo aquí, porque los HashMap no son iguales a las listas o arrays donde los índices son numéricos y se definen automáticamente. Aquí tú defines qué quieres usar como clave: puede ser un número, una cadena de texto, o incluso un objeto. Eso te da mucha flexibilidad para organizar tus datos.

¿Cómo crear un HashMap en Java?

Lo cierto es que crearlos es bastante sencillo. Solo necesitas usar su constructor y definir los tipos de datos que serán las claves y los valores.

Te lo muestro mejor en este ejemplo:

import java.util.HashMap;

public class EjemploHashMap {
    public static void main(String[] args) {
        // Crear un HashMap para almacenar productos y precios
        HashMap<String, Double> productos = new HashMap<>();
    }
}

En este caso, las claves serán cadenas (String) y los valores serán números decimales (Double).

Si prefieres usar la interfaz genérica Map (que es el contrato común de las implementaciones de mapas en Java), la cosa cambia:

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

Map<String, Double> productos = new HashMap<>();

Métodos esenciales de HashMap

Este mapa no está solo sino que viene con varios métodos que hacen que trabajar con él sea muy práctico.

Te explico los más importantes:

Agregar elementos con put

Con put podrás añadir una clave y su valor asociado:

productos.put("Manzanas", 2.50);
productos.put("Peras", 3.00);

Obtener un valor con get

Si conoces la clave, puedes usar get para recuperar el valor asociado:

double precioManzanas = productos.get("Manzanas");
System.out.println("El precio de las manzanas es: " + precioManzanas);

Eliminar elementos con remove

Si ya no necesitas un elemento, puedes eliminarlo con remove:

productos.remove("Peras");

Limpiar con clear

Si necesitas vaciar el mapa completamente:

productos.clear();

Obtener todas las claves con keySet

Puedes usar el método keySet para obtener un conjunto con todas las claves y recorrerlo:

for (String producto : productos.keySet()) {
    System.out.println(producto);
}

Cómo iterar sobre un HashMap

Para recorrer todas las entradas, puedes usar un bucle for-each en combinación con el método entrySet:

for (Map.Entry<String, Double> entrada : productos.entrySet()) {
    System.out.println("Producto: " + entrada.getKey() + ", Precio: " + entrada.getValue());
}

Esta es una gran forma de acceder tanto a las claves como a los valores.

Cómo usar objetos como claves

Por si no lo sabías, en estos mapas también puedes usar tus propias clases como claves. Sin embargo, debes asegurarte de que tu clase implemente correctamente los métodos equals() y hashCode() para que el mapa funcione como esperas.

Ejemplo con una clase personalizada

class Empleado {
    private String id;
    private String nombre;

    // Constructor, getters, equals y hashCode
    public Empleado(String id, String nombre) {
        this.id = id;
        this.nombre = nombre;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Empleado empleado = (Empleado) obj;
        return id.equals(empleado.id);
    }

    @Override
    public int hashCode() {
        return id.hashCode();
    }
}

public class EjemploEmpleadoHashMap {
    public static void main(String[] args) {
        HashMap<Empleado, Double> salarios = new HashMap<>();
        Empleado e1 = new Empleado("123", "Ana");
        Empleado e2 = new Empleado("124", "Luis");

        salarios.put(e1, 5000.0);
        salarios.put(e2, 6000.0);

        System.out.println("Salario de Ana: " + salarios.get(e1));
    }
}

En caso de que olvides implementar equals() y hashCode(), lo que sucederá es que tu mapa no podrá identificar correctamente las claves.

Consejos prácticos

1. Usa claves inmutables: Es mejor usar claves que no cambien una vez creadas, como cadenas o números. Si una clave mutable cambia después de añadirse al mapa, podrías perder acceso a su valor.
2. Evita claves nulas: Aunque el mapa permite una clave nula, esto puede generar confusiones si no lo manejas correctamente.
3. Elige el tamaño inicial adecuado: Si esperas almacenar muchos datos, define un tamaño inicial para evitar redimensionamientos frecuentes.
4. Considera otras estructuras: Si necesitas ordenar las claves, un TreeMap podría ser más adecuado.

En el Bootcamp de Java Full Stack de KeepCoding, aprenderás a dominar estructuras de datos como y mucho más. Desde conceptos básicos hasta la creación de aplicaciones completas, te prepararemos para una carrera exitosa en IT. ¡Apúntate hoy y transforma tu futuro con nosotros!