Dominando Java HashMap: Operaciones, Ejemplos y Mejores Prácticas

Dominando Java HashMap

Explora la clase HashMap de Java—sus características principales, operaciones comunes y ejemplos prácticos—para que puedas usarla confidentemente en aplicaciones reales.

La clase HashMap, parte del framework de colecciones de Java, implementa una tabla hash que almacena datos en pares clave/valor. Cada clave es única y actúa como identificador de su valor asociado. La clase implementa la interfaz Map, proporcionando una API versátil para manipular datos.

---

Creando un HashMap

Comienza importando el paquete java.util.HashMap:

import java.util.HashMap;

Luego instancia el mapa. Puedes especificar tipos genéricos de clave K y valor V, o confiar en la inferencia de tipos:

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

Ejemplo con tipos concretos:

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

---

Ejemplo 1: Creación Básica de HashMap

import java.util.HashMap;
class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> lenguajes = new HashMap<>();
        lenguajes.put("Java", 8);
        lenguajes.put("JavaScript", 1);
        lenguajes.put("Python", 3);
        System.out.println("HashMap: " + lenguajes);
    }
}

Salida

HashMap: {Java=8, JavaScript=1, Python=3}

---

Operaciones Principales en HashMap

La clase HashMap ofrece un rico conjunto de métodos. Cubriremos los más usados:

• Añadir elementos
• Acceder a elementos
• Actualizar elementos
• Eliminar elementos

---

1. Añadiendo Elementos

Usa put() para insertar un par clave/valor. Si la clave ya existe, el valor se reemplaza.

import java.util.HashMap;
class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> numeros = new HashMap<>();
        System.out.println("HashMap Inicial: " + numeros);
        numeros.put("Uno", 1);
        numeros.put("Dos", 2);
        numeros.put("Tres", 3);
        System.out.println("HashMap después de put(): " + numeros);
    }
}

Salida

HashMap Inicial: {} HashMap después de put(): {Uno=1, Dos=2, Tres=3}

Clave: String, Valor: Integer en este ejemplo.

---

2. Accediendo a Elementos

Recupera un valor con get(clave). El método devuelve null si la clave está ausente.

import java.util.HashMap;
class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> lenguajes = new HashMap<>();
        lenguajes.put(1, "Java");
        lenguajes.put(2, "Python");
        lenguajes.put(3, "JavaScript");
        System.out.println("HashMap: " + lenguajes);
        String valor = lenguajes.get(1);
        System.out.println("Valor en clave 1: " + valor);
    }
}

Salida

HashMap: {1=Java, 2=Python, 3=JavaScript} Valor en clave 1: Java

También puedes obtener el conjunto completo de claves, colección de valores o conjunto de entradas vía keySet(), values() y entrySet():

import java.util.HashMap;
class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> lenguajes = new HashMap<>();
        lenguajes.put(1, "Java");
        lenguajes.put(2, "Python");
        lenguajes.put(3, "JavaScript");
        System.out.println("HashMap: " + lenguajes);
        System.out.println("Claves: " + lenguajes.keySet());
        System.out.println("Valores: " + lenguajes.values());
        System.out.println("Entradas: " + lenguajes.entrySet());
    }
}

Salida

HashMap: {1=Java, 2=Python, 3=JavaScript} Claves: [1, 2, 3] Valores: [Java, Python, JavaScript] Entradas: [1=Java, 2=Python, 3=JavaScript]

---

3. Actualizando Valores

El método replace(clave, nuevoValor) intercambia el valor existente para la clave dada. Devuelve el valor anterior o null si la clave estaba ausente.

import java.util.HashMap;
class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> lenguajes = new HashMap<>();
        lenguajes.put(1, "Java");
        lenguajes.put(2, "Python");
        lenguajes.put(3, "JavaScript");
        System.out.println("HashMap Original: " + lenguajes);
        lenguajes.replace(2, "C++");
        System.out.println("Después de replace(): " + lenguajes);
    }
}

Salida

HashMap Original: {1=Java, 2=Python, 3=JavaScript} Después de replace(): {1=Java, 2=C++, 3=JavaScript}

---

4. Eliminando Elementos

Elimina un mapeo con remove(clave), que devuelve el valor eliminado. Para eliminación condicional, usa remove(clave, valor), que solo elimina si el mapeo actual coincide con el valor especificado.

import java.util.HashMap;
class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> lenguajes = new HashMap<>();
        lenguajes.put(1, "Java");
        lenguajes.put(2, "Python");
        lenguajes.put(3, "JavaScript");
        System.out.println("HashMap: " + lenguajes);
        String eliminado = lenguajes.remove(2);
        System.out.println("Valor eliminado: " + eliminado);
        System.out.println("HashMap Actualizado: " + lenguajes);
    }
}

Salida

HashMap: {1=Java, 2=Python, 3=JavaScript} Valor eliminado: Python HashMap Actualizado: {1=Java, 3=JavaScript}

---

Métodos Adicionales de HashMap

Método	Descripción
clear()	Elimina todos los mapeos
compute()	Calcula un nuevo valor para una clave
computeIfAbsent()	Calcula un valor solo si la clave falta
computeIfPresent()	Calcula un valor solo si la clave existe
merge()	Fusiona un nuevo mapeo con uno existente
clone()	Crea una copia superficial
containsKey()	Verifica una clave específica
containsValue()	Verifica un valor específico
size()	Número de pares clave/valor
isEmpty()	Si el mapa está vacío

---

Iterando a Través de un HashMap

Usa un bucle for-each para recorrer claves, valores o entradas. Importa java.util.Map.Entry para iterar entradas.

import java.util.HashMap;
import java.util.Map.Entry;
class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> lenguajes = new HashMap<>();
        lenguajes.put(1, "Java");
        lenguajes.put(2, "Python");
        lenguajes.put(3, "JavaScript");
        System.out.println("HashMap: " + lenguajes);
        System.out.print("Claves: ");
        for (Integer clave : lenguajes.keySet()) {
            System.out.print(clave + ", ");
        }
        System.out.print("\nValores: ");
        for (String valor : lenguajes.values()) {
            System.out.print(valor + ", ");
        }
        System.out.print("\nEntradas: ");
        for (Entry<Integer, String> entrada : lenguajes.entrySet()) {
            System.out.print(entrada + ", ");
        }
    }
}

Salida

HashMap: {1=Java, 2=Python, 3=JavaScript} Claves: 1, 2, 3, Valores: Java, Python, JavaScript, Entradas: 1=Java, 2=Python, 3=JavaScript,

---

Creando un HashMap desde Otro Mapa

Instancia un HashMap con el contenido de un mapa existente:

import java.util.HashMap;
import java.util.TreeMap;
class Main {
    public static void main(String[] args) {
        TreeMap<String, Integer> numerosPares = new TreeMap<>();
        numerosPares.put("Dos", 2);
        numerosPares.put("Cuatro", 4);
        System.out.println("TreeMap: " + numerosPares);
        HashMap<String, Integer> numeros = new HashMap<>(numerosPares);
        numeros.put("Tres", 3);
        System.out.println("HashMap: " + numeros);
    }
}

Salida

TreeMap: {Cuatro=4, Dos=2} HashMap: {Dos=2, Tres=3, Cuatro=4}

Parámetros opcionales del constructor permiten establecer capacidad inicial y factor de carga:

HashMap<K, V> numeros = new HashMap<>(8, 0.6f);

• Capacidad: 8 entradas antes de rehash.
• Factor de carga: 0.6 dispara redimensionado al 60% de llenado.

Los valores por defecto son capacidad = 16 y factor de carga = 0.75.

Para más detalles, consulta la documentación oficial de Java o recursos autoritativos como "Effective Java" de Joshua Bloch.