How to flatten a map inside a list?

I have a list of maps, each map showing the same key attributes type and value.

Question: how can I use java streams to flatten this into a Map<String, List>>?

List<Map<String, Object>> source = List.of(
	Map.of("type", "first_type", "value", "1"),
	Map.of("type", "first_type", "value", "2"),
	Map.of("type", "second_type", "value", "3")
);

Goal:
Map<String, List<Object>> goal = Map.of(
	"first_type", List.of("1", "2"),
	"second_type", List.of("3")
);

It's probably similar to the following, but how can I group the nested map values by their type?

 source.stream()
            .collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()));

We can achieve this using Collectors.groupingBy.

Map<String, List<Object>> goal = source.stream()
        .collect(Collectors.groupingBy(e -> (String) e.get("type"),
                Collectors.mapping(e -> e.get("value"), Collectors.toList())));

Since the key of the result map is a String, there is an ugly type-casting when extracting the key (type).

You can use Collectors.groupingBy to grouping by type and Collectors.mapping to map the value and collect as List

Map<Object, List<Object>> goal = 
  source.stream()
        .collect(Collectors.groupingBy(m -> m.get("type"),
                  Collectors.mapping(m -> m.get("value"), Collectors.toList())));

It's better get result in Map<Object, List<Object>> as map key is Object to avoid type casting.

Just Stream the maps and pull off the type and values. Then map them to a list.
This uses groupingBy to group the values into a target supplier. But you need to map the value first and then specify the supplier as a List. I also changed Object to String since that is what you are using.

Map<String, List<String>> map =
		source.stream()
				.collect(Collectors.groupingBy(m->m.get("type"),
						Collectors.mapping(m->m.get("value"),
								Collectors.toList())));

map.entrySet().forEach(System.out::println);

Prints

first_type=[1, 2]
second_type=[3]

Of course, you could also do it like this. This translates to:

• if the ArrayList is there for the specified key type, use it.
• otherwise create it.
• In either case it returns that list from the compute method where<br>
  the value for the value key is added.

Map<String,List<String>> map = new HashMap<>();
for(Map<String,String> m : source) {
	map.compute(m.get("type"), (k,v)-> v == null ?
            new ArrayList<>(): v).add(m.get("value"));
}

</details>