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) + "")); 

There are various ways to achieve this. Here are three.

    Map<String, String> map = new HashMap<String, String>();
    map.put("key1", "value1");
    map.put("key2", "value2");
    map.put("key3", "value3");

    System.out.println("using entrySet and toString");
    for (Entry<String, String> entry : map.entrySet()) {
        System.out.println(entry);
    }
    System.out.println();

    System.out.println("using entrySet and manual string creation");
    for (Entry<String, String> entry : map.entrySet()) {
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }
    System.out.println();

    System.out.println("using keySet");
    for (String key : map.keySet()) {
        System.out.println(key + "=" + map.get(key));
    }
    System.out.println();

Output

using entrySet and toString
key1=value1
key2=value2
key3=value3

using entrySet and manual string creation
key1=value1
key2=value2
key3=value3

using keySet
key1=value1
key2=value2
key3=value3

How can we use Collectors.joining as an intermediate step ?

You mean, in the collecting phase...

Yes, you can:

Map<String, String> result = 
        source.entrySet()
              .stream()
              .collect(toMap(Map.Entry::getKey, 
                      e -> e.getValue().stream().collect(joining(", "))));

but, better to use String.join:

Map<String, String> result = 
     source.entrySet()
           .stream()
           .collect(toMap(Map.Entry::getKey, e -> String.join(", ", e.getValue())));

or none stream variant:

Map<String, String> resultSet = new HashMap<>();
source.forEach((k, v) -> resultSet.put(k, String.join(",", v)));

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}

As others have pointed out, you're not using the ideal structure for your data. But this should do what you want under the circumstances:

Map<String, Map<String, String>> distancesBySource = distances.stream()
        .collect(Collectors.groupingBy(m -> m.get("Source"),
                Collectors.toMap(m -> m.get("Destination"), m -> m.get("distance"))));

I think you're looking for something like this:

import java.util.*;
import java.util.stream.*;
public class Test {

    public static void main(String[] args) throws Exception {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "foo");
        map.put(2, "bar");
        map.put(3, "baz");
        String result = map.entrySet()
            .stream()
            .map(entry -> entry.getKey() + " - " + entry.getValue())
            .collect(Collectors.joining(", "));
        System.out.println(result);
    }
}

To go through the bits in turn:

• entrySet() gets an iterable sequence of entries
• stream() creates a stream for that iterable
• map() converts that stream of entries into a stream of strings of the form "key - value"
• collect(Collectors.joining(", ")) joins all the entries in the stream into a single string, using ", " as the separator. Collectors.joining is a method which returns a Collector which can work on an input sequence of strings, giving a result of a single string.

Note that the order is not guaranteed here, because HashMap isn't ordered. You might want to use TreeMap to get the values in key order.

You can do it like this.

The data

Map<String, List<String>> map = Map.of("North America",
        List.of("New York", "Vancouver", "Paris"), "Europe",
        List.of("London", "Paris"));

The process

• stream the entrySet
• flatMap the list and map to an array
• then build the new map with the results of the array.
• I added a merge function to handle duplicate keys in case a city is in two countries.

Map<String, String> result = map.entrySet().stream()
        .flatMap(e -> e.getValue().stream()
                .map(str -> new String[] { str, e.getKey() }))
        .collect(Collectors.toMap(a -> a[0], a -> a[1],
                (countries, country)->countries + ", " + country,
                HashMap::new));

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

prints

New York=North America
Vancouver=North America
London=Europe
Paris=Europe, North America

Instead of using string concatenation to handle duplicates you could also do this using a Map<String,List<String>> to handle duplicate cities. Here is how that would look.

Map<String, List<String>> result = map.entrySet().stream()
        .flatMap(e -> e.getValue().stream()
                .map(str -> new String[] { str, e.getKey() }))
        .collect(Collectors.groupingBy(a -> a[0],
            Collectors.mapping(a -> a[1], Collectors.toList())));

In order to get a List of a different type than the type of the Stream elements, you should chain a Collectors.mapping collector to groupingBy:

Map<String, Map<String, List<String>>> testMap = 
    foos.stream()
        .collect(Collectors.groupingBy(Foo::getAreaName,
                                       Collectors.groupingBy(Foo::getObjectName,
                                                             Collectors.mapping(Foo::getLineName,
                                                                                Collectors.toList()))));

Well you can't safely cast it to a Map<String, String> because even though you know you've only got strings as the values, the compiler doesn't. That's like expecting:

Object x = "foo";
String y = x;

to work - it doesn't; you need to explicitly cast.

Likewise you can explicitly cast here, too, if you go via Object:

Map<String, Object> x = ...;
Map<String, String> y = (Map<String, String>) (Object) x;

Now you'll get a warning saying that it's an unchecked cast, because unlike the earlier "object to string" cast, there's no execution-time check that it's really valid. Type erasure means that a map doesn't really know its key/value types. So you end up with checking only being done when elements are fetched:

import java.util.*;

class Test {
    public static void main(String[] args) {
        Map<String, Object> x = new HashMap<>();
        x.put("foo", "bar");
        x.put("number", 0);
        Map<String, String> y = (Map<String, String>) (Object) x;
        // This is fine
        System.out.println(y.get("foo"));

        // This goes bang! It's trying to cast an Integer to a String
        System.out.println(y.get("number"));
    }
}

So if you really want to avoid creating a new map, this "cast via Object" will work - but it's far from ideal.

Your approach is safer, although you can make it slightly more efficient by avoiding the lookup:

public static Map<String, String> copyToStringValueMap(
        Map<String, Object> input) {
    Map<String, String> ret = new HashMap<>();
    for (Map.Entry<String, Object> entry : input.entrySet()) {
        ret.put(entry.getKey(), (String) entry.getValue());
    }
    return ret;
}

public class HashMap extends AbstractMap that is why you need to dig into AbstractMap Online for example you can find it here: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/AbstractMap.java#AbstractMap.toString%28%29 The same thing with ArrayList or others, just go to the eldest parent possible and check code ```java /** * Returns a string representation of this map. The string representation * consists of a list of key-value mappings in the order returned by the * map's entrySet view's iterator, enclosed in braces * ("{}"). Adjacent mappings are separated by the characters * ", " (comma and space). Each key-value mapping is rendered as * the key followed by an equals sign ("=") followed by the * associated value. Keys and values are converted to strings as by * {@link String#valueOf(Object)}. * * @return a string representation of this map */ public String toString() { Iterator> i = entrySet().iterator(); if (! i.hasNext()) return "{}"; StringBuilder sb = new StringBuilder(); sb.append('{'); for (;;) { Entry e = i.next(); K key = e.getKey(); V value = e.getValue(); sb.append(key == this ? "(this Map)" : key); sb.append('='); sb.append(value == this ? "(this Map)" : value); if (! i.hasNext()) return sb.append('}').toString(); sb.append(',').append(' '); } } ```