HashMap

HashMap<K,V> es una clase en Java que permite almacenar datos en forma de pares clave-valor (key-value). Este es uno de los tipos más comunes de mapa, y es ideal cuando necesitas una forma rápida de acceder a valores basándote en claves únicas. Los HashMap son extremadamente eficientes para buscar y recuperar datos gracias al uso de tablas hash.

Las características principales de HashMap son:

• Acceso rápido: Proporciona un tiempo de acceso constante para operaciones como la búsqueda y la inserción de elementos, siempre que la tabla hash esté bien distribuida.
• Claves únicas: No se permiten claves duplicadas; si se agrega un nuevo par con una clave ya existente, el valor anterior es sustituido.
• Permite nulos: A diferencia de otros mapas, un HashMap permite un único valor null como clave y múltiples valores null como valores.
• No mantiene orden: Los elementos de un HashMap no se almacenan en ningún orden específico; no se garantiza el orden de inserción ni de ninguna otra clase.

Creación de HashMap

Para usar un HashMap, primero hay que importarlo desde el paquete java.util. Aquí tienes algunos ejemplos de creación:

import java.util.HashMap;

// HashMap vacío de pares String-Integer
HashMap<String, Integer> edades = new HashMap<>(); 

// HashMap con capacidad inicial de 20 pares Integer-String
HashMap<Integer, String> nombres = new HashMap<>(20);

Principales métodos de HashMap

A continuación te muestro los métodos más importantes que se usan para trabajar con HashMap o cualquier Map en Java:

• Agregar o sustituir elementos: V put(K clave, V valor) Agrega un nuevo par clave-valor al HashMap. Si la clave ya existe, el valor anterior es sustituido.

  edades.put("Ana", 25);
  edades.put("Carlos", 30);

• Obtener un valor por clave: V get(K clave) Retorna el valor asociado a una clave específica. Si la clave no existe, retorna null.

  Integer edad = edades.get("Ana"); // Retorna 25

• Eliminar un par clave-valor: V remove(K clave) Elimina el par clave-valor asociado a una clave específica.

  edades.remove("Carlos"); // Elimina el par ("Carlos", 30)

• Comprobar si contiene una clave o valor: boolean containsKey(K clave) y boolean containsValue(V valor) Comprueba si el HashMap contiene una clave o valor específico.

  boolean existeClave = edades.containsKey("Ana"); // Retorna true
  boolean existeValor = edades.containsValue(30); // Retorna false (si "Carlos" fue eliminado)

• Obtener el tamaño del HashMap: int size() Retorna el número de pares clave-valor en el HashMap.

  int tamaño = edades.size(); // Retorna 1 si solo queda ("Ana", 25)

• Comprobar si está vacío: boolean isEmpty() Comprueba si el HashMap no contiene ningún par clave-valor.

  boolean estaVacio = edades.isEmpty(); // Retorna false

• Obtener conjuntos de claves y valores:

  • Set<K> keySet(): Retorna un Set de todas las claves.

  • Collection<V> values(): Retorna una colección de todos los valores.

    ArrayList<String> claves = new ArrayList<>(productos.keySet()); // Todas las claves ("Ana")
    ArrayList<Integer> valores = new ArrayList<>(productos.values()); // Todos los valores (25)

• Limpiar el HashMap: void clear() Elimina todos los pares clave-valor del HashMap.

  edades.clear(); // El HashMap queda vacío

Recorrer un HashMap

Para recorrer un HashMap la opción preferible es utilizar el método entrySet() junto a la estructura for.

Ejemplo:

for (Map.Entry<String, Integer> entry : map.entrySet()) {
   System.out.println("Clave: " + entry.getKey() + ", Valor: " + entry.getValue());
}

Un ejemplo más sencillo recorriendo las claves del HashMap:

for (String clave : map.keySet()) {
   Integer valor = map.get(clave);
   System.out.println("Clave: " + clave + ", Valor: " + valor);
}