As said in JavaDocs:

If the mapped keys contains duplicates (according to Object.equals(Object)), an IllegalStateException is thrown when the collection operation is performed. If the mapped keys may have duplicates, use toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction) instead.

So you should use toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction) instead. Just provide a merge function, that will determine which one of duplicates is put in the map.

For example, if you don't care which one, just call

Map<String, String> phoneBook = people.stream().collect(
        Collectors.toMap(Person::getName, Person::getAddress, (a1, a2) -> a1));

Problem statement: Converting SimpleImmutableEntry<String, List<String>> -> Map<String, List<String>>.

For Instance you have a SimpleImmutableEntry of this form [A,[1]], [B,[2]], [A, [3]] and you want your map to looks like this: A -> [1,3] , B -> [2].

This can be done with Collectors.toMap but Collectors.toMap works only with unique keys unless you provide a merge function to resolve the collision as said in java docs.

https://docs.oracle.com/javase/8/docs/api/java/util/stream/Collectors.html#toMap-java.util.function.Function-java.util.function.Function-java.util.function.BinaryOperator-

So the example code looks like this:

          .map(returnSimpleImmutableEntries)
          .collect(Collectors.toMap(SimpleImmutableEntry::getKey,
                                    SimpleImmutableEntry::getValue,
                                    (oldList, newList) -> { oldList.addAll(newList); return oldList; } ));

returnSimpleImmutableEntries method returns you entries of the form [A,[1]], [B,[2]], [A, [3]] on which you can use your collectors.

You can use groupingBy

getMapStream()
      .map(item -> Arrays.asList(item))
      .collect(Collectors.groupingBy(l->l.get(0),
           Collectors.mapping(l1->l1.get(1),Collectors.toList())));

or use toMap() with merge function.

     Map<String,List<String>> vehicle = getMapStream()
            .collect(Collectors.toMap(item->item[0],
       item->new ArrayList<>(Arrays.asList(item[1])),
                            (l1,l2)->{l1.addAll(l2);return l1;}));

You can’t use Collectors.toMap, because it requires unique keys. What you want instead is groupingBy, which returns collected values for each key:

class Location {
    public final String city;
    public final String country;

    Location(Address address) {
        this.city = address.getCity();
        this.country = address.getCountry();
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Location) {
            Location other = (Location) obj;
            return Objects.equals(this.city, other.city) &&
                   Objects.equals(this.country, other.country);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return Objects.hash(city, country);
    }
}

Map<Location, Set<String>> statesByLocation = addresses.stream().collect(
    Collectors.groupingBy(Location::new,
        Collectors.mapping(Address::getState, Collectors.toSet())));

You could employ various hacks for combining city and country (like a list of two Strings), but you really should just make a key class as shown above. The code will be far easier to work with, especially if you (or another developer) should have a reason to come back to it in six months.

As for the Collector methods:

• Collectors.groupingBy(Location::new is equivalent to address -> new Location(address) and creates each key in the Map.
• Collectors.mapping(Address::getState, Collectors.toSet()) means that each Address which corresponds to a particular key will have getState() invoked on it, and the resulting strings will be aggregated in a Set to form the Map value.

Personally, I think I would opt for a simple for-loop instead of the hard-to-read Stream approach:

Map<Location, Set<String>> statesByLocation = new HashMap<>();
for (Address address : addresses) {
    statesByLocation.computeIfAbsent(new Location(address),
        k -> new HashSet<String>()).add(address.getState());
}