Iterate Map in java
There are different ways to iterate a map in java.
java.util.Map is an interface. There are various implementations of Map such as HashMap , TreeMap , LinkedHashMap .
All the methods outlined in this article can be used for iterating over any of these types.
Method 1 : forEach() java map
Starting java 8, forEach() method is added to java.util.Map interface. This method can be used to iterate through a hashmap.
In every iteration, it is supplied with two arguments, one is a key and another is the value of current map entry.
In the current example, we just print the key and value of the entry.
import java.util.HashMap; import java.util.Map; public class MapIterator < public static void main(String[] args) < // create a hashmap Mapmap = new HashMap(); // add values map.put(1, "mango"); map.put(2, "orange"); map.put(3, "guava"); map.forEach((key, value) -> < // print key System.out.println("Key: " + key); // print value System.out.println("Value: " + value); >); > > forEach() method takes an argument of type java.util.function.BiConsumer which is a functional interface having a method which accepts two arguments.
Hence, we can supply a Lambda expression to forEach() method with two arguments which are the key and value of a map element.
If you print both key and value in a single statement, then curly braces in lambda expression can be omitted as shown below.
map.forEach((key, value) -> System.out.println("Key: " + key + ", value text-align: justify;">Above code prints Key: 1, value= mango
Key: 2, value= orange
Key: 3, value= guava
Method 2: Using entrySet()
A map stores data in key-value pairs also known as entries. These entries are instances of type java.util.Map.Entry which is a nested interface of java.util.Map interface.
Each entry corresponds to a map element and contains key and value for that element with methods to retrieve them(getKey() and getValue()) and modify them(setKey() and setValue()).
Entries stored in a map can be retrieved by calling entrySet() method on the map. This set can then be iterated using a for loop as shown below.
import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class MapIterator < public static void main(String[] args) < // create a hashmap Mapmap = new HashMap(); // add values map.put(1, "mango"); map.put(2, "orange"); map.put(3, "guava"); // get all map entries Set> entrySet = map.entrySet(); // iterate over entries using a for loop for (Entry entry : entrySet) < // get key and value of each entry System.out.println("Key: "+entry.getKey()); System.out.println("Value: "+entry.getValue()); >> > Key: 1
Value: mango
Key: 2
Value: orange
Key: 3
Value: guava
Note that the for loop used in this example is an enhanced for loop or a for-each loop.
Method 3 : Iterator on entrySet()
As discussed above, elements of a map are stored as entries and entrySet() method returns those entries in the form of a java.util.Set .
This set can also be iterated using a java.util.iterator .
A java iterator contains a hasNext() method which returns true if the set has an element to be iterated and a next() method that returns the set element at the current iterator position.
When next() is called, iterator moves on to the next element in the set. Example,
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; public class MapIterator < public static void main(String[] args) < // create a hashmap Mapmap = new HashMap(); // add values map.put(1, "mango"); map.put(2, "orange"); map.put(3, "guava"); // get iterator over the map entries Iterator iterator = map.entrySet().iterator(); // iterate over entries using a loop while(iterator.hasNext()) < // get current map entry Entryentry = iterator.next(); // get key and value of each entry System.out.println("Key: "+entry.getKey()); System.out.println("Value: "+entry.getValue()); > > >
Output of above program is
Key: 1
Value: mango
Key: 2
Value: orange
Key: 3
Value: guava
Method 4 : keySet() and iterator
A map has a keySet() method which returns a java.util.Set of all the keys of the map. This set of keys can be iterated using a java.util.iterator .
In every iteration, the iterator’s next() method will return the key for a map entry. This key can be used to retrieve the corresponding value using get() method of the map.
get() method accepts a key for the map entry and returns the corresponding value. Example,
import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class MapIterator < public static void main(String[] args) < // create a hashmap Mapmap = new HashMap(); // add values map.put(1, "mango"); map.put(2, "orange"); map.put(3, "guava"); // get iterator over the keys of map Iterator iterator = map.keySet().iterator(); // iterate over map key while (iterator.hasNext()) < // get current map key Integer key = iterator.next(); System.out.println("Key: " + key); // get value of this key System.out.println("Value: " + map.get(key)); >> > Remember that this method will search the entire map for the value of a key till it is found and is thus an inefficient method of iteration when compared to other methods described above.
Method 5 : Using Stream.of() java 8
A map can also be iterated using java 8 streams .
Stream provides a static of() method which accepts a collection and returns a stream over it.
Retrieve set of map entries using entrySet() method which returns a java.util.Set and pass it to Stream.of() method.
Now, you can easily iterate over this stream using forEach() method as shown below.
import java.util.HashMap; import java.util.Map; import java.util.stream.Stream; public class MapIterator < public static void main(String[] args) < // create a hashmap Mapmap = new HashMap(); // add values map.put(1, "mango"); map.put(2, "orange"); map.put(3, "guava"); // iterate with Stream.of Stream.of(map.entrySet()).forEach(e -> < System.out.println(e); >); > >
Hope the article was useful.
HashMap iteration in Java
HashMap iteration in Java tutorial shows how to iterate over a HashMap in Java.
Java HashMap
is a container that stores key-value pairs. Each key is associated with one value. Keys in a HashMap must be unique. HashMap is called an associative array or a dictionary in other programming languages. HashMaps take more memory because for each value there is also a key. Deletion and insertion operations take constant time. HashMaps can store null values.
represents a key-value pair in HashMap . HashMap's entrySet returns a Set view of the mappings contained in the map. A set of keys is retrieved with the keySet method.
HashMap iteration with forEach()
In the first example, we use Java 8 forEach method to iterate over the key-value pairs of the HashMap . The forEach method performs the given action for each element of the map until all elements have been processed or the action throws an exception.
package com.zetcode; import java.util.HashMap; import java.util.Map; public class HashMapForEach < public static void main(String[] args) < Mapitems = new HashMap<>(); items.put("coins", 5); items.put("pens", 2); items.put("chairs", 7); items.forEach((k, v) -> < System.out.format("key: %s, value: %d%n", k, v); >); > > In the code example, we iterate over a HashMap with forEach using a lambda expression.
Map items = new HashMap<>(); items.put("coins", 5); items.put("pens", 2); items.put("chairs", 7); A HashMap is created with a couple of pairs.
The forEach makes the code more concise.
HashMap iteration with Stream API
is a sequence of elements from a source that supports sequential and parallel aggregate operations. The source can be a collection, IO operation, or array, which provides data to a stream.
package com.zetcode; import java.util.HashMap; public class HashMapStreamApi < public static void main(String[] args) < HashMapitems = new HashMap<>(); items.put("coins", 5); items.put("pens", 2); items.put("chairs", 7); items.entrySet().stream().forEach(e -> < System.out.format("key: %s, value: %d%n", e.getKey(), e.getValue()); >); > > The example iterates over a HashMap with the stream API. We get the entry set with entrySet method and from the entry set, we get the stream with the stream method. Later, we iterate over the stream with forEach .
HashMap iteration with enhanced for loop
Enhanced for loop, introduced in Java 5, can be used to iterate over a HashMap .
package com.zetcode; import java.util.HashMap; import java.util.Map; public class HashMapEnhancedFor < public static void main(String[] args) < HashMapitems = new HashMap(); items.put("coins", 5); items.put("pens", 2); items.put("chairs", 7); for (Map.Entry pair: items.entrySet()) < System.out.format("key: %s, value: %d%n", pair.getKey(), pair.getValue()); >> > In the example, we iterate over a HashMap with enhanced for loop.
for (Map.Entry pair: items.entrySet())
In each for cycle, a new key-value couple is assigned to the pair variable.
HashMap iteration with Iterator
In the following example, we iterate over a HashMap with Iterator and Map.Entry .
package com.zetcode; import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class HashMapIterator < public static void main(String[] args) < Mapitems = new HashMap<>(); items.put("coins", 5); items.put("pens", 2); items.put("chairs", 7); Iterator it = items.entrySet().iterator(); while (it.hasNext()) < Map.Entrypair = it.next(); System.out.format("key: %s, value: %d%n", pair.getKey(), pair.getValue()); > > > In the code example we retrieve an iterator over the key-value pairs and iterate over the mappings in the while loop.
Iterator> it = items.entrySet().iterator();
We get the iterator object. First, we get the entry set with the entrySet method and from the entry set we get the iterator with iterator method.
The iterator's hasNext method returns true if the iteration has more elements.
The next method returns the next pair.
System.out.format("key: %s, value: %d", pair.getKey(), pair.getValue()); With getKey and getValue methods we get the key and the value of the pair.
The following example is the same but uses a for loop instead of while.
package com.zetcode; import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class HashMapIterator2 < public static void main(String[] args) < Mapitems = new HashMap<>(); items.put("coins", 5); items.put("pens", 2); items.put("chairs", 7); for (Iterator it = items.entrySet().iterator(); it.hasNext();) < Map.Entrypair = it.next(); System.out.format("key: %s, value: %d%n", pair.getKey(), pair.getValue()); > > > In the example, we iterate over a HashMap with an iterator and for loop.
In the next example, we iterate over a key set with an iterator while using HashMap's keySet method, which returns a Set view of the keys contained in this map. This iteration is less efficient.
package com.zetcode; import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class HashMapIterator3 < public static void main(String[] args) < Mapitems = new HashMap<>(); items.put("coins", 5); items.put("pens", 2); items.put("chairs", 7); Iterator it = items.keySet().iterator(); while (it.hasNext()) < String key = it.next(); System.out.format("key: %s, value: %d%n", key, items.get(key)); >> > In the example, we iterate over the key set of the map with an iterator. The iterator is used in a while loop to go over the keys of the map. The key is later used to get the corresponding value.
Iterator it = items.keySet().iterator();
We get the iterator object of the key set.
In the while loop, we traverse over the keys of the HashMap .
The next key is retrieved.
System.out.format("key: %s, value: %d%n", key, items.get(key)); The value is retrieved with the get method.
HashMap iteration over keys
We may need to iterate only over keys of a HashMap .
package com.zetcode; import java.util.HashMap; import java.util.Map; import java.util.Set; public class HashMapKeys < public static void main(String[] args) < Mapitems = new HashMap<>(); items.put("coins", 5); items.put("pens", 2); items.put("chairs", 7); Set keys = items.keySet(); keys.forEach(System.out::println); > > The example iterates over keys of a HashMap .
The keys of a HashMap are retrieved with the keySet method, which returns a Set of keys. Keys must be unique; therefore, we have a Set . Set is a collection that contains no duplicate elements.
keys.forEach(System.out::println);
We go over the set of keys with forEach .
HashMap iteration over values
We may need to iterate only over values of a HashMap .
package com.zetcode; import java.util.Collection; import java.util.HashMap; import java.util.Map; public class HashMapValues < public static void main(String[] args) < Mapitems = new HashMap<>(); items.put("coins", 5); items.put("pens", 2); items.put("chairs", 7); Collection vals = items.values(); vals.forEach(System.out::println); > > The example iterates over values of a HashMap .
Collection vals = items.values();
The values of a HashMap are retrieved with the values method.
vals.forEach(System.out::println);
We go over the collection with forEach .
Iteration over HashMap containing ArrayList
A HashMap can contain lists as values. In such a case, we need an additional loop.
package com.zetcode; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; public class HashMapList < public static void main(String[] args) < Map> m = new HashMap<>(); m.put("colours", Arrays.asList("red", "green", "blue")); m.put("sizes", Arrays.asList("small", "medium", "big")); for (Map.Entry> me : m.entrySet()) < String key = me.getKey(); Listvalues = me.getValue(); System.out.println("Key: " + key); System.out.print("Values: "); for (String e : values) < System.out.printf("%s ", e); >System.out.println(); > > > In the example, we iterate over a HashMap that contains ArrayLists as values. We use two for loops.
Map> m = new HashMap<>(); m.put("colours", Arrays.asList("red", "green", "blue")); m.put("sizes", Arrays.asList("small", "medium", "big")); We define a HashMap having ArrayLists as values.
for (Map.Entry> me : m.entrySet())
With enhanced for loop, we go through the entry set. Each entry has a key string and list value.
We get the key with getKey method.
We get the list with getValue .
In the inner for loop, we iterate over the list of values.
HashMap filtering
HashMap can be filtered with the filter method of the Stream API.
package com.zetcode; import java.util.HashMap; import java.util.Map; import java.util.stream.Collectors; public class HashMapFilter < public static void main(String[] args) < Mapcapitals = new HashMap<>(); capitals.put("svk", "Bratislava"); capitals.put("ger", "Berlin"); capitals.put("hun", "Budapest"); capitals.put("czk", "Prague"); capitals.put("pol", "Warsaw"); capitals.put("ita", "Rome"); Map filteredCapitals = capitals.entrySet().stream() .filter(map -> map.getValue().startsWith("B")) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); filteredCapitals.entrySet().forEach(System.out::println); > > In the example, we have a map of countries with their capitals. We filter the map to contain only pairs whose values begin with B.
In this article we have shown how to iterate over a HashMap in Java.
Author
My name is Jan Bodnar and I am a passionate programmer with many years of programming experience. I have been writing programming articles since 2007. So far, I have written over 1400 articles and 8 e-books. I have over eight years of experience in teaching programming.