If you are preparing for a coding interview, and Java is your programming language of choice, you will benefit from reviewing some of the basics of Java. Software engineers or developers often prefer object-oriented programming languages, like Java, for the features and ease they offer. In this article, we will look at one such feature — the map. Specifically, we’ll cover:
- What is a Map in Java?
- How to iterate through a Map in Java: 5 Methods
- FAQs on how to iterate a Map in Java
What Is a Map in Java?
The Map in Java contains elements based on key-value pairs, i.e., a unique key is assigned to each value. The Map comes in handy when we need to search, update, and remove items based on a key. Following are the types of Maps in Java:
- HashMap
- LinkedHashMap
- Treemap
- Hashtable
The Map is not a collection, but it is still considered part of the collection. Thus, a Map is an interface that extends the collection interface. An iterator is an interface that is used to iterate through the collection.
How to Iterate Through a Map in Java
In Java, a group of objects that can be represented as a single unit is a collection of objects. We can iterate on collections using iterators. As Maps are not a collection, we cannot iterate on them using iterators.
We have to employ other methods to iterate through a Map. In this article, we will discuss five methods. Let’s get started.
Method 1: Iterating Over Map.entrySet() Using a For-Each Loop
We can use the Map.entrySet() method to return a collection-view(Set<Map.Entry<K, V>>) of the mapping contained in the given Map. Thus, we can easily iterate over the key-value pairs of our Map by using methods of Map.Entry<K, V> like getKey() and getValue().
This method can be used when we need both keys and values in the loop. Here’s the implementation:
import java.util.Map;
import java.util.HashMap;
public class Method_1
{
public static void main(String[] arg)
{
Map<String,String> myMap = new HashMap<String,String>();
// Inserting entries in map.
myMap.put("IK", "InterviewKickstart");
myMap.put("Java", "ProgrammingLanguage");
myMap.put("SE", "SoftwareEngineer");
// Using for-each loop for iteration over Map.entrySet()
for (Map.Entry<String,String> itr : myMap.entrySet())
System.out.println("Key = " + itr.getKey() + ": Value = " + itr.getValue());
}
}
Output:
Key = Java: Value = ProgrammingLanguage
Key = IK: Value = InterviewKickstart
Key = SE: Value = SoftwareEngineer
Method 2: Iterating Over Keys/Values Using keySet() and values() Methods
Method Map.keySet() is used to return a Set view of the keys contained in the Map.
Also, the Map.values() method is used to return the collection-view of the values contained in the Map. We can iterate over keySets or values using for-each loops to get the keys or values of the map separately. This method can be used when we only need to work with keys or values but not both.
Here’s the code:
// Iterating over keys or values using keySet() and values() methods.
import java.util.Map;
import java.util.HashMap;
public class Method_2
{
public static void main(String[] arg)
{
Map<String,String> myMap = new HashMap<String,String>();
// Inserting entries in map.
myMap.put("IK", "InterviewKickstart");
myMap.put("Java", "ProgrammingLanguage");
myMap.put("SE", "SoftwareEngineer");
// using keySet() for iterating over keys
for (String k : myMap.keySet())
System.out.println("key: " + k);
// using values() for iterating over values
for (String v : myMap.values())
System.out.println("value: " + v);
}
}
Output
key: Java
key: IK
key: SE
value: ProgrammingLanguage
value: InterviewKickstart
value: SoftwareEngineer
Method 3: Iterating Using Iterators Over Map.Entry<K, V>
This method is similar to method 1. We used a for-each loop on Map.Entry<K, V> in the first method, but in this method, we use methods like getKey() and getValue() of Map. We can use the entrySet() method to get the Set view of the mapping contained in the map and then can access key or value using getKey() or getValue() method on entry.
Let’s have a look at the code:
// Iterating using iterators over Map.Entry<K, V>.
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
public class Method_2
{
public static void main(String[] arg)
{
Map<String,String> myMap = new HashMap<String,String>();
// Inserting entries in map.
myMap.put("IK", "InterviewKickstart");
myMap.put("Java", "ProgrammingLanguage");
myMap.put("SE", "SoftwareEngineer");
// Using iterators
Iterator<Map.Entry<String, String>> it = myMap.entrySet().iterator();
// Iterating till the last key value pair.
while(it.hasNext())
{
Map.Entry<String, String> x = it.next();
System.out.println("Key = " + x.getKey() + ": Value = " + x.getValue());
}
}
}
Output:
Key = Java: Value = ProgrammingLanguage
Key = IK: Value = InterviewKickstart
Key = SE: Value = SoftwareEngineer
Method 4: Using the forEach(action) Method
In the latest versions of Java, like Java 8, we can iterate a Map using the inbuilt Map.forEach(action) method and lambda expressions in Java.
Here’s the code:
// Using forEach(action) method.
import java.util.Map;
import java.util.HashMap;
public class Method_2
{
public static void main(String[] arg)
{
Map<String,String> myMap = new HashMap<String,String>();
// Inserting entries in map.
myMap.put("IK", "InterviewKickstart");
myMap.put("Java", "ProgrammingLanguage");
myMap.put("SE", "SoftwareEngineer");
// Using forEach(action) method to iterate over map.
myMap.forEach((key,val) -> System.out.println("Key = " + key + ": Value = " + val));
}
}
Output:
Key = Java: Value = ProgrammingLanguage
Key = IK: Value = InterviewKickstart
Key = SE: Value = SoftwareEngineer
Method 5: Iterating Over Keys and Searching for Values
In this method, we first loop over all keys in Map using Map.keySet() method and then search for the value associated with a particular key using Map.get(key) method.
Following is the code to implement this method:
// Iterating over keys and searching for values.
import java.util.Map;
import java.util.HashMap;
public class Method_2
{
public static void main(String[] arg)
{
Map<String,String> myMap = new HashMap<String,String>();
// Inserting entries in map.
myMap.put("IK", "InterviewKickstart");
myMap.put("Java", "ProgrammingLanguage");
myMap.put("SE", "SoftwareEngineer");
// Looping on the keys in the map.
for (String k : myMap.keySet())
{
// Searching for the value.
String val = myMap.get(k);
System.out.println("Key = " + k + ": Value = " + val);
}
}
}
Output:
Key = Java: Value = ProgrammingLanguage
Key = IK: Value = InterviewKickstart
Key = SE: Value = SoftwareEngineer
FAANG Interview Questions on Java Iterate Map
Here are some sample questions on iterating through a Map in Java:
- What will happen if you try to store a key that is already present in a Java Map?
- What is the requirement for an object to be used as a key or value in Java HashMap?
- What are the different ways to iterate over Maps in Java?
- How do you remove a mapping while iterating over HashMap in Java?
For more tech interview questions and problems, check out the following pages: Interview Questions, Problems, Learn.
FAQs on Java Iterate Map
Question 1: In Java, why is the collection interface not extended by the Map interface?
Mainly because they are incompatible, the collection has a method add(Object o). The Map cannot have such a method because it needs a key-value pair. Also, there are other reasons like Map supports keySet, valueSet. Collection classes do not have such methods. Due to such significant differences, the Map interface does not use a collection interface.
Question 2: What is the difference between Iterator and Enumeration in Java?
There are three significant differences between iterators and enumeration:
- In Enumerator, we can not add/remove elements from a collection, Although, In Iterators, we can remove elements from the underlying collection in the iteration using its inbuilt remove() method.
- Availability: An Iterator is available in all modern collection classes. An enumerator is available in legacy classes, i.e., Vector/Stack, etc.
- Iterator has more improved method names than Enumerator. For example, In Enumerator, there is a method hasMoreElement(), which becomes hasNext() in the Iterator.
Recommended Reading
Check out our learn page for more articles on Java:
Ace Your Next Tech Interview With Interview Kickstart!
If you’re looking for guidance and help to nail your next technical interview, sign up for our free webinar.
As pioneers in the field of technical interview prep, we have trained thousands of software engineers to crack the toughest coding interviews and land their dream jobs at Google, Facebook, Apple, Netflix, Amazon, and other Tier-1 tech companies.
Join our webinar to learn more!
---------
Article contributed Omkar Deshmukh
.png)
