1. Overview
When working in Java, it’s common to have two separate lists that need to be associated. In other words, we are given two lists, one contains keys and the other carries values. Then we want to get a Map, which associates each element of the key list with the corresponding element in the value list.
In this tutorial, we’ll explore how to achieve this in different ways.
2. Introduction to the Problem
As usual, let’s understand the problem through an example. Let’s say we have two lists:
final List<String> KEY_LIST = Arrays.asList("Number One", "Number Two", "Number Three", "Number Four", "Number Five");
final List<Integer> VALUE_LIST = Arrays.asList(1, 2, 3, 4, 5);
Now, we would like to associate the two lists above with a Map. But first, let’s initialize a HashMap containing the expected key-value pairs:
final Map<String, Integer> EXPECTED_MAP = new HashMap<String, Integer>() {{
put("Number One", 1);
put("Number Two", 2);
put("Number Three", 3);
put("Number Four", 4);
put("Number Five", 5);
}};
As the code above shows, the rule to combine two lists is pretty straightforward. Next, let’s see how we can achieve that.
3. A Word About the Validation
Now that we understand the problem, we may have realized that the given two lists must contain the same number of elements, like KEY_LIST and VALUE_LIST. However, in practice, as we cannot predict the data quality we’ve got, the two given lists could have different sizes. If this is the case, we must follow the requirements to perform further operations. Usually, there could be two options:
- Throw an exception and break the associating operation
- Report the mismatch problem as a warning and continue creating the Map object to contain only the matched elements
We can implement this using a simple if check:
int size = KEY_LIST.size();
if (KEY_LIST.size() != VALUE_LIST.size()) {
// throw an exception or print a warning and take the smaller size and continue:
size = min(KEY_LIST.size(), VALUE_LIST.size());
}
// using the size variable for further processings
For simplicity, we’ll assume the two lists always have the same size and omit this validation in further code examples. Moreover, we’ll use unit test assertions to verify whether the approach returns the expected result.
4. Filling the Map in a Loop
As the two input lists have the same size, we can associate the two lists with a single loop. Next, let’s see how it’s done:
Map<String, Integer> result = new HashMap<>();
for (int i = 0; i < KEY_LIST.size(); i++) {
result.put(KEY_LIST.get(i), VALUE_LIST.get(i));
}
assertEquals(EXPECTED_MAP, result);
As the example above shows, we create a new HashMap called result. We then iterate through each element in KEY_LIST using a for loop, and for each element, we retrieve the corresponding element from VALUE_LIST using the same index i. Then, the put() method fills the key-value pair into the result map.
5. Using the Stream API
Stream API provides many concise and efficient ways to manipulate Java collections. So next, let’s use the Java Stream API to associate two lists:
Map<String, Integer> result = IntStream.range(0, KEY_LIST.size())
.boxed()
.collect(Collectors.toMap(KEY_LIST::get, VALUE_LIST::get));
assertEquals(EXPECTED_MAP, result);
As we see in the code above, the IntStream.range() method generates a stream of integers from 0 to the size of KEY_LIST. It’s worth mentioning that IntStream is a primitive stream. Therefore, we use the boxed() method to convert the IntStream to a Stream<Integer>, which allows us to use the collect() method to collect the elements into a Map.
6. Using Iterator
We’ve learned two approaches to associate two lists and get a Map as a result. However, if we take a closer look at these two solutions, we see both approaches used the List.get() method. In other words, we call List.get(i) to access the element by index while building up the association. This is called random access.
If our lists are ArrayList, which might be the most common case, the data is backed by an array. Therefore, random access is fast.
However, if we’re given two large LinkedList, accessing elements by index can be slow. This is because LinkedList requires iterating through the list from the beginning to the desired index.
Therefore, using an Iterator can be a more efficient way to traverse the list, especially for large lists:
Map<String, Integer> result = new HashMap<>();
Iterator<String> ik = KEY_LIST.iterator();
Iterator<Integer> iv = VALUE_LIST.iterator();
while (ik.hasNext() && iv.hasNext()) {
result.put(ik.next(), iv.next());
}
assertEquals(EXPECTED_MAP, result);
In this example, we create two Iterator objects, one for each list. Then, we use a while loop to iterate over both lists simultaneously, using the next() method of each Iterator to retrieve the next element in the list. For each pair of elements, we put the key and the value into the result HashMap, just like in the previous example.
7. Conclusion
In this article, we’ve learned three ways to combine two given lists into a map through examples.
First, we solved the problem with a for loop and Stream based on the list of random access. Then, we discussed the performance issue of the random access approaches when our input is LinkedList.
Finally, we saw the Iterator-based solution so that we can have better performance no matter which List implementation we have.
As usual, all code snippets presented here are available over on GitHub.
