You can use groupingBy instead of toMap:

Map<String, Set<A>> sysUidToAMap =  
    mySet.stream()
         .collect(Collectors.groupingBy(A::getSystemID,
                                        Collectors.toSet()));

That's because you are setting Entry::getValue as Map's value which is JsonElement and not a BigDecimal. You need to convert it into BigDecimal in collect, e.g.:

Set<Entry<String, JsonElement>> entries = jsonObject.entrySet();
ImmutableMap<String, BigDecimal> map = entries.stream()
    .collect(Collectors.collectingAndThen(Collectors.toMap(e -> e.getKey(), e -> e.getValue().getAsBigDecimal()), ImmutableMap::copyOf));

I ended up with a fairly straight-forward one line solution with Java 8 as follows:

Map<String, Foo> map = fooSet.stream().collect(Collectors.toMap(Foo::getKey, e -> e));

• fooSet is a set of objects of type Foo, i.e. Set<Foo> fooSet
• Foo has a getter called getKey which returns a String

Use

// in Java 22+, you should name the "k" below as "_"
map.computeIfAbsent(node1, k -> new LinkedHashSet<>()).add(node2);

If node1 is already found in the map, it will be equivalent to:

map.get(node1).add(node2);

If node1 is not already in the map, it will be equivalent to:

map.put(node1, new LinkedHashSet<>()).add(node2);

This is exactly what you're looking for, and is even described as a use case in the documentation.

Here you go:

Set<String> allStrings = map.values()
   .stream()
   .flatMap(Set::stream)
   .collect(Collectors.toSet());

You can use a series of Stream.map and Stream.flatMap:

List<Map<String, List<String>>> input = ...;

Set<String> output = input.stream()    // -> Stream<Map<String, List<String>>>
    .map(Map::values)                  // -> Stream<List<List<String>>>
    .flatMap(Collection::stream)       // -> Stream<List<String>>
    .flatMap(Collection::stream)       // -> Stream<String>
    .collect(Collectors.toSet())       // -> Set<String>
    ;

Try something like this:

import static java.util.stream.Collectors.*;
import org.apache.commons.lang3.tuple.Pair;
// ...snip...
sections.stream()
        .flatMap(section->section.getGrids()
                                 .stream()
                                 .map(Grid::getRows)
                                 .flatMap(Set::stream)
                                 .map(row->new Pair(row.getEmail(), section.getId())))
        .collect(groupingBy(Pair::getKey, mapping(Pair::getValue, toSet())));