How to iterate through a HashMap?

If you're using Java 8 you can take advantage of lambda expressions to write compact code:

datos.forEach((k,v) -> System.out.println("Key: " + k + ": Value: " + v));

There is no need to use EntrySet, the data types of kand vare automatically inferred.

There is no way to iterate over the HashMap directly, but you can iterate over it.entrySet()

For example:

Map<Integer, String> datos = new HashMap<Integer, String>();
datos.put(1, "uno");
datos.put(2, "dos");
datos.put(3, "tres");

for (Map.Entry<Integer, String> entry : datos.entrySet()) {
    System.out.println("clave=" + entry.getKey() + ", valor=" + entry.getValue());
}

Source: Stack Overflow by Jesper

Reference link: How to Iterate Over a Map in Java

There are several ways to iterate over a map in java. We will see the most common methods and review their advantages and disadvantages. Since all maps in java implement the interface Map, the following techniques will work for any implementation of Map( HashMap, TreeMap, LinkedHashMap, Hashtable, etc.)

Method #1: Iterating over the inputs using For-Each.

It is the most common and the most preferable in most cases. It would be used in the case that you need both value and key.

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}

Note that the For-Each loop was introduced in Java 5 so it only works in early versions of java. Also the loop For-Eachwill throw NullPointerExceptionif you try to iterate over a map nulo, so always check for references first nulas.

Method #2: Iterating over the keys or values ​​using a For-Each loop.

If you only need either the keys or the values ​​you can use keySetor valuesinstead of entrySet.

    Map<Integer, Integer> map = new HashMap<Integer, Integer>();

    //iterating over keys only
    for (Integer key : map.keySet()) {
        System.out.println("Key = " + key);
    }

//iterando solo sobre valores
for (Integer value : map.values()) {
    System.out.println("Value = " + value);
}

This method gives a slight performance advantage over iteration entrySet (about 10% faster) and is cleaner.

Method #3: Iterating using Iterator.

Using Generics:

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry<Integer, Integer> entry = entries.next();
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}

Without Generics:

Map map = new HashMap();
Iterator entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry entry = (Map.Entry) entries.next();
    Integer key = (Integer)entry.getKey();
    Integer value = (Integer)entry.getValue();
    System.out.println("Key = " + key + ", Value = " + value);
}

You can also use the same technique to iterate over keySetor values.

This method may seem redundant but it has its advantages. First of all it is the only way to iterate over maps in older versions of java. Another important feature is that this is the only method that allows you to remove entries from the map during iteration using iterator.remove(). If you try to do this with a For-Each iteration you will get "unpredictable results" according to the JavaDoc.

From a performance point of view this is the same as a For-Each iteration.

Method #4: Iterating over keys and looking for values ​​(inefficient).

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Integer key : map.keySet()) {
    Integer value = map.get(key);
    System.out.println("Key = " + key + ", Value = " + value);
}

This would seem to be a cleaner alternative to method #1 but in practice it is very slow and inefficient getting values ​​by key could be very time consuming (this method in different implementations of Mapis 20%-200% slower than method #1). If you have FindBugs installed, it will detect it and warn you of an inefficient iteration. This method should be avoided.

Conclusion:

If you only want keys or values ​​use method #2. If you are stuck on some old version of java (less than 5) or plan to remove entries during iteration use method #3. Otherwise use #1.

The interface Map(implemented by HashMap) has an entrySet() method which returns a view of the Map as Set. And those Setare iterables:

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

Please note that the one Setreturned by entrySet()is not a copy. It is backed by it, Mapso all changes made to one will affect the other.
This also means that, in case of multi-threaded applications, you have to be careful not to modify the Mapwhile iterating Setin this way.

It is also possible to iterate an instance of java.util.Mapwith the help of the keySet. This method returns an instance of java.util.Set, which is a view of the map. Any change to it will affect the map.

• Code :

  for (int key : datos.keySet()) {
      System.out.printf("Clave=%d, Valor=%s%n", key, datos.get(key));
  }
  

• Output :

  Clave=1, Valor=uno
  Clave=2, Valor=dos
  Clave=3, Valor=tres
  

In my opinion, on many occasions the following code is more intuitive and practical:

HashMap<Integer, String> datos = new HashMap<>();
datos.put(1, "uno");
datos.put(2, "dos");
datos.put(3, "tres");

for (String dato : datos.values()) 
{   System.out.println(dato);
    ...
}