You were almost correct with groupingBy, but the second parameter of that is a Collector, not a Function. Thus I used toMap.

 Map<String, Integer> map = Stream.of("bla", "blabla", "blablabla").distinct()
            .collect(Collectors.toMap(Function.identity(), String::length));

Split the string by , to get individual map entries. Then split them by = to get the key and the value.

Map<String, String> reconstructedUtilMap = Arrays.stream(utilMapString.split(","))
            .map(s -> s.split("="))
            .collect(Collectors.toMap(s -> s[0], s -> s[1]));

Note: As pointed out by Andreas@ in the comments, this is not a reliable way to convert between a map and a string

EDIT: Thanks to Holger for this suggestion.

Use s.split("=", 2) to ensure that the array is never larger than two elements. This will be useful to not lose the contents (when the value has =)

Example: when the input string is "a=1,b=2,c=3=44=5555" you will get {a=1, b=2, c=3=44=5555}

Earlier (just using s.split("=")) will give {a=1, b=2, c=3}

You can use IntStream to get this thing done. Use the integer value as the key, and the relevant value in the string array at that index as the value of the map.

Map<Integer, String> counterToStr = IntStream.range(0, strings.length)
    .boxed()
    .collect(Collectors.toMap(Function.identity(), i -> strings[i]));

Another alternative that obviates the need of split would be,

Map<Integer, String> counterToStr = IntStream.range(0, strings.length)
    .boxed()
    .collect(Collectors.toMap(Function.identity(), i -> str.charAt(i) + "")); 

I think what you have there is fine, assuming \\. matches the single character ..

However, you can clean it up a bit by compiling the regex into a Pattern and using Stream#map:

Pattern pattern = Pattern.compile("[.]");

Arrays.asList("Stack.Overflow")
      .stream()
      .map(pattern::split)
      .collect(Collectors.toMap(s -> s[0], s -> s[1]));

Output:

{Stack=Overflow}

You can modify your solution to collect the Stream of String arrays into a Map (instead of using forEach) :

Map<String, Double> kvs =
    Arrays.asList("a:1.0", "b:2.0", "c:3.0")
        .stream()
        .map(elem -> elem.split(":"))
        .collect(Collectors.toMap(e -> e[0], e -> Double.parseDouble(e[1])));

Of course this solution has no protection against invalid input. Perhaps you should add a filter just in case the split String has no separator :

Map<String, Double> kvs =
    Arrays.asList("a:1.0", "b:2.0", "c:3.0")
        .stream()
        .map(elem -> elem.split(":"))
        .filter(elem -> elem.length==2)
        .collect(Collectors.toMap(e -> e[0], e -> Double.parseDouble(e[1])));

This still doesn't protect you against all invalid inputs (for example "c:3r" would cause NumberFormatException to be thrown by parseDouble).

You can use the following snippet for this:

Map<String, Map<String, String>> result = Arrays.stream(samp.split(","))
        .map(i -> i.split("-"))
        .collect(Collectors.groupingBy(a -> a[0], Collectors.toMap(a -> a[1], a -> a[2])));

First it creates a Stream of your items, which are mapped to a stream of arrays, containing the subitems. At the end you collect all by using group by on the first subitem and create an inner map with the second value as key and the last one as value.

The result is:

{101={1=5, 2=4}, 102={1=5, 2=5, 3=5}, 103={1=4}}

Since you want to return the result map of the first Result element to pass your filter, you can obtain it with findFirst():

Optional<Map<String,Integer>> resultMap = 
    resultList.stream()
              .filter(result->"xxx".equals(result.getName()))
              .map(Result::getResultMap)
              .findFirst();

You can extract the Map from the Optional this way:

Map<String,Integer> resultMap = 
    resultList.stream()
              .filter(result->"xxx".equals(result.getName()))
              .map(Result::getResultMap)
              .findFirst()
              .orElse(null);