Convert a Stream into a Map or Multimap in Java

1. Introduction

Streams became integral for Java after the release of Java 8. They serve as potent, eloquent ways of processing data. As such, there are times when one may have to transform an element of a stream into a Map or Multimap.

In this tutorial, we’ll have a deep look at the ways of transforming a stream into a Map or Multimap in Java using different approaches and libraries.

2. Conversion of Stream to Map

2.1. Using Collectors.toMap()

To convert the stream into a Map, we can utilize the Collectors.toMap() function. Such a collector specifies the key-value mapping function, which maps every item in a stream accordingly. Here’s a basic example:

@Test
public void givenStringStream_whenConvertingToMapWithMerge_thenExpectedMapIsGenerated() {
    Stream<String> stringStream = Stream.of("one", "two", "three", "two");

    Map<String, String> mergedMap = stringStream.collect(
      Collectors.toMap(s -> s, s -> s, (s1, s2) -> s1 + ", " + s2)
    );

    // Define the expected map
    Map<String, String> expectedMap = Map.of(
      "one", "one",
      "two", "two, two",
      "three", "three"
    );

    assertEquals(expectedMap, mergedMap);
}

The above test method starts by creating a Stream of strings stringStream, which is put into a Map using Collectors.toMap(). This function takes each string as its key and value, separated by commas, to consolidate multiple entries for the same key.

2.2. Using Stream.reduce()

We may also use the Stream.reduce() operator. This method can help us construct the values of the stream into a Map using an identity and an accumulation function.

@Test
public void givenStringStream_whenConvertingToMapWithStreamReduce_thenExpectedMapIsGenerated() {
    Stream<String> stringStream = Stream.of("one", "two", "three", "two");

    Map<String, String> resultMap = stringStream.reduce(
      new HashMap<>(), (map, element) -> {
        map.put(element, element);
            return map;
        },
        (map1, map2) -> {
            map1.putAll(map2);
            return map1;
        }
    );

    Map<String, String> expectedMap = new HashMap<>();
    expectedMap.put("one", "one");
    expectedMap.put("two", "two");
    expectedMap.put("three", "three");

    assertEquals(expectedMap, resultMap);
}

Note that the Stream.reduce() operator encounters duplicate values for the same key. It accumulates them differently from the previous section. Instead of overwriting the existing value with the last encountered value, it aggregates them by creating a list of values for that key.

This is why “two” is mapped to a list containing two “two” values in the resulting map, whereas in section 2.1, it concatenated them with a comma.

3. Conversion of Stream to Multimap

3.1. Using Guava’s Multimap

There is the Multimap interface that is found in Google’s Guava library, which maps a specific key to multiple values. First, we need to include it as a dependency in our project:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.3-jre</version>
</dependency>

Then, we utilize it to convert a stream into a ListMultimap as follows:

@Test
public void givenStringStream_whenConvertingToMultimap_thenExpectedMultimapIsGenerated() {
    Stream<String> stringStream = Stream.of("one", "two", "three", "two");

    ListMultimap<String, String> multimap = stringStream.collect(
            ArrayListMultimap::create,
            (map, element) -> map.put(element, element),
            ArrayListMultimap::putAll
    );

    ListMultimap<String, String> expectedMultimap = ArrayListMultimap.create();
    expectedMultimap.put("one", "one");
    expectedMultimap.put("two", "two");
    expectedMultimap.put("two", "two");
    expectedMultimap.put("three", "three");

    assertEquals(expectedMultimap, multimap);
}

In the above code, we utilize the ArrayListMultimap::create method to collect the stringStream elements. Furthermore, the (map, element) -> map.put(element, element) iterates through the stream elements to put each element into the multimap. This ensures that both keys and values in the multimap are the same, maintaining the duplicate entries. The third function, ArrayListMultimap::putAll, combines multiple multimap results into one if needed.

3.2. Using Stream.reduce()

The other way of transforming a stream into a Multimap is by applying the reduce operation on the stream. In turn, this enables us to accomplish the conversion task through an identity value as well as an accumulation function:

@Test
public void givenStringStream_whenConvertingToMultimapWithStreamReduce_thenExpectedMultimapIsGenerated() {
    Stream<String> stringStream = Stream.of("one", "two", "three", "two");

    Map<String, List<String>> multimap = stringStream.reduce(
      new HashMap<>(),
      (map, element) -> {
          map.computeIfAbsent(element, k -> new ArrayList<>()).add(element);
          return map;
      },
      (map1, map2) -> {
          map2.forEach((key, value) -> map1.merge(key, value, (list1, list2) -> {
              list1.addAll(list2);
              return list1;
          }));
          return map1;
      }
    );

    Map<String, List<String>> expectedMultimap = new HashMap<>();
    expectedMultimap.put("one", Collections.singletonList("one"));
    expectedMultimap.put("two", Arrays.asList("two", "two"));
    expectedMultimap.put("three", Collections.singletonList("three"));

    assertEquals(expectedMultimap, multimap);
}

Here, through the reduce operation, the test method accumulates the elements of stringStream into a multimap, where each unique string is mapped to a list of its occurrences. We also use lambda expressions to handle the mapping and merging of values and then ensure the correctness of the transformation through assertions.

3. Conclusion

In summary, Java streams offer efficient data processing, and this tutorial has covered methods like Collectors.toMap(), Stream.reduce(), and Guava’s Multimap for transforming streams into Map and Multimap. These methods empower us to handle data effectively in Java, providing flexibility to choose the right approach for our project’s needs.