¿Cómo iterar HashMap en Java?

HashMap es una parte de la colección de Java que proporciona la implementación básica de la interfaz Map de Java al almacenar los datos en pares (Clave, Valor) para acceder a ellos mediante un índice de otro tipo. Un objeto aparece como clave (índice) para otro objeto (valor). Si intenta insertar la clave duplicada, reemplazará el elemento de la clave correspondiente. Para utilizar esta clase y sus métodos, es necesario importar el paquete java.util.HashMap o su superclase.

Hay numerosas formas de iterar sobre HashMap, de las cuales 5 se enumeran a continuación: 

1. Iterar a través de un HashMap EntrySet usando iteradores.
2. Iterar a través de HashMap KeySet usando Iterator.
3. Iterar HashMap usando for-each loop .
4. Iterando a través de un HashMap usando Lambda Expressions.
5. Recorra un HashMap usando Stream API .

Método 1: Usar un bucle for para iterar a través de un HashMap. Iterando un HashMap a través de un bucle for para usar las funciones getValue() y getKey() .

Implementación: en el código que se proporciona a continuación, entrySet() se usa para devolver una vista de conjunto de elementos mapeados. Del código dado a continuación:

• set.getValue() para obtener valor del conjunto.
• set.getKey() para obtener la clave del conjunto.

// Java Program to Iterate over HashMap
 
// Importing Map and HashMap classes
// from package names java.util
import java.util.HashMap;
import java.util.Map;
 
// Class for iterating HashMap using for loop
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating a HashMap
        Map<String, String> foodTable
            = new HashMap<String, String>();
 
        // Inserting elements to the adobe HashMap
        // Elements- Key value pairs using put() method
        foodTable.put("A", "Angular");
        foodTable.put("J", "Java");
        foodTable.put("P", "Python");
        foodTable.put("H", "Hibernate");
 
        // Iterating HashMap through for loop
        for (Map.Entry<String, String> set :
             foodTable.entrySet()) {
 
            // Printing all elements of a Map
            System.out.println(set.getKey() + " = "
                               + set.getValue());
        }
    }
}

P = Python
A = Angular
H = Hibernate
J = Java

Método 2: Usar un forEach para iterar a través de un HashMap. En el segundo método, la función forEach para iterar los pares clave-valor.

// Java Program to Iterate over HashMap
// Iterating HashMap using forEach
 
// Importing Map and HashMap classes
// from package names java.util
import java.util.HashMap;
import java.util.Map;
 
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating hash map
        Map<Character, String> charType
            = new HashMap<Character, String>();
 
        // Inserting data in the hash map.
        charType.put('J', "Java");
        charType.put('H', "Hibernate");
        charType.put('P', "Python");
        charType.put('A', "Angular");
 
        // Iterating HashMap through forEach and
        // Printing all. elements in a Map
        charType.forEach(
            (key, value)
                -> System.out.println(key + " = " + value));
    }
}

P = Python
A = Angular
H = Hibernate
J = Java

Método 3: Usar un iterador para recorrer un HashMap. En este método, el iterador se usa para iterar cada par mapeado en HashMap como se muestra en el siguiente programa java.

Ejemplo:

// Java Program to Iterate over HashMap
// Using Iterator
 
// Importing classes from java.util package
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
 
public class GFG {
 
    // Main driver method
    public static void main(String[] arguments)
    {
        // Creating Hash map
        Map<Integer, String> intType
            = new HashMap<Integer, String>();
 
        // Inserting data(Key-value pairs) in hashmap
        intType.put(1, "First");
        intType.put(2, "Second");
        intType.put(3, "Third");
        intType.put(4, "Fourth");
 
        // Iterator
        Iterator<Entry<Integer, String> > new_Iterator
            = intType.entrySet().iterator();
 
        // Iterating every set of entry in the HashMap
        while (new_Iterator.hasNext()) {
            Map.Entry<Integer, String> new_Map
                = (Map.Entry<Integer, String>)
                      new_Iterator.next();
 
            // Displaying HashMap
            System.out.println(new_Map.getKey() + " = "
                               + new_Map.getValue());
        }
    }
}

1 = First
2 = Second
3 = Third
4 = Fourth

 Método 4: iterar a través de un HashMap usando expresiones lambda

Una expresión lambda es un bloque corto de código que toma parámetros y devuelve un valor. Las expresiones lambda son similares a los métodos, pero no necesitan un nombre y se pueden implementar directamente en el cuerpo de un método. La expresión lambda más simple contiene un solo parámetro y una expresión:

parameter -> expression

Ejemplo: 

// Iterating HashMap using Lambda Expressions- forEach()
// Importing Map and HashMap classes
// from java.util package
import java.util.HashMap;
import java.util.Map;
 
// Class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating hash map
        Map<Character, String> charType
            = new HashMap<Character, String>();
 
        // Inserting elements(key-value pairs)
        // in the hash map ( Custom inputs)
        charType.put('A', "Apple");
        charType.put('B', "Basketball");
        charType.put('C', "Cat");
        charType.put('D', "Dog");
 
        // Iterating through forEach and
        // printing the elements
        charType.forEach(
            (key, value)
                -> System.out.println(key + " = " + value));
    }
}

A = Apple
B = Basketball
C = Cat
D = Dog

Método 5: recorrer un HashMap usando Stream API

El siguiente ejemplo itera sobre un HashMap con la ayuda de la API de transmisión. 

Stream API se utiliza para procesar colecciones de objetos.

Los flujos no cambian la estructura de datos original, solo proporcionan el resultado según los métodos canalizados

 Pasos :

• Primero invoque el método entrySet().stream() que a su vez devuelve el objeto Stream.
• Siguiente método forEach , que itera los objetos de entrada que están en el conjunto de entradas(). Vea el siguiente código.

Ejemplo:

// Java Program to Iterate over HashMap
// Loop through a HashMap using Stream API
 
// Importing classes from
// package named 'java.util'
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
 
// HashMap class
public class GFG {
 
    // Main driver method
    public static void main(String[] arguments)
    {
        // Creating hash map
        Map<Integer, String> intType
            = new HashMap<Integer, String>();
 
        // Inserting data(key-value pairs) in HashMap
        // Custom inputs
        intType.put(1, "First");
        intType.put(2, "Second");
        intType.put(3, "Third");
        intType.put(4, "Fourth");
 
        // Iterating every set of entry in the HashMap, and
        // printing all elements of it
        intType.entrySet().stream().forEach(
            input
            -> System.out.println(input.getKey() + " : "
                                  + input.getValue()));
    }
}

1 : First
2 : Second
3 : Third
4 : Fourth