mjhjmtu

I have a Map<String, String> and a List<String>. I'd like to partition the Map based on the condition

foreach(map.key -> list.contains(map.key))

and produce two Map(s). What's the most elegant way to do so? I'm on Java 11, so you can throw everything you want in the answers.

What I came up to for now is:

map.entrySet()
 .stream()
 .collect(partitioningBy(e -> list.contains(o.getKey())));

but that gives a Map<Boolean, List<Entry<String, String>>>.

You can reduce each group using toMap (as a downstream collector):

Map<String, String> myMap = new HashMap<>();
myMap.put("d", "D");
myMap.put("c", "C");
myMap.put("b", "B");
myMap.put("A", "A");

List<String> myList = Arrays.asList("a", "b", "c");

Map<Boolean, Map<String, String>> result = myMap.entrySet()
 .stream()
 .collect(Collectors.partitioningBy(
 entry -> myList.contains(entry.getKey()),
 Collectors.toMap(Entry::getKey, Entry::getValue)
 )
 );

And for this example, that produces false=A=A, d=D, true=b=B, c=C

Though partitioningBy is the way to go when you need both the alternatives as an output based on the condition. Yet, another way out (useful for creating map based on a single condition) is to use Collectors.filtering as :

Map<String, String> myMap = Map.of("d", "D","c", "C","b", "B","A", "A");
List<String> myList = List.of("a", "b", "c");
Predicate<String> condition = myList::contains;

Map<String, String> keysPresentInList = myMap.keySet()
 .stream()
 .collect(Collectors.filtering(condition,
 Collectors.toMap(Function.identity(), myMap::get)));
Map<String, String> keysNotPresentInList = myMap.keySet()
 .stream()
 .collect(Collectors.filtering(Predicate.not(condition),
 Collectors.toMap(Function.identity(), myMap::get)));

or alternatively, if you could update the existing map in-place, then you could retain entries based on their key's presence in the list using just a one-liner:

myMap.keySet().retainAll(myList);

You can't really produce two separate maps using streams (at least not in the most elegant way). Don't be afraid to use the old regular forEach, I think it's quite a clean version:

Map<String, String> contains = new HashMap<>();
Map<String, String> containsNot = new HashMap<>();

for(Map.Entry<String, String> entry : yourMap.entrySet()) 
 if (yourList.contains(entry.getKey())) 
 contains.put(entry.getKey(), entry.getValue());
 else 
 containsNot.put(entry.getKey(), entry.getValue());
 

You can have filtered map by applying filtering on the original map, e.g.:

List<String> list = new ArrayList<>(); //List of values
Map<String, String> map = new HashMap<>();

Map<String, String> filteredMap = map.entrySet()
.stream()
.filter(e -> list.contains(e.getKey()))
.collect(Collectors.toMap(Entry::getKey, Entry::getValue));

You can then compare the filteredMap contents with original map to extract the entries that are not present in the filteredMap.

You could iterate the map and use the goodies introduced in Java 8+:

Map<Boolean, Map<String, String>> result = Map.of(true, new LinkedHashMap<>(), 
 false, new LinkedHashMap<>());
Set<String> set = new HashSet<>(list);
map.forEach((k, v) -> result.get(set.contains(k)).put(k, v));

First, we create a result map with two entries, one for each partition. The values are LinkedHashMaps so that insertion order is preserved.

Then, we create a HashSet from the list, so that invoking set.contains(k) is a O(1) operation (otherwise, if we did list.contains(k), this would be O(n) for each entry of the map, thus yielding a total time complexity of O(n^2), which is bad).

Finally, we iterate the input map and put the (k, v) entry in the corresponding partition, as per the result of invoking set.contains(k).

As a supplement to @ernest_k 's answer you can use a function and groupingBy:

Map<String, String> myMap = new HashMap<>();
myMap.put("d", "D");
myMap.put("c", "C");
myMap.put("b", "B");
myMap.put("A", "A");
List<String> myList = Arrays.asList("a", "b", "c");

Function<Entry<String, String> , Boolean> myCondition = i -> myList.contains(i.getKey());

Map<Boolean,List<Entry<String, String>>> myPartedMap = myMap.entrySet()
 .stream().collect(Collectors.groupingBy(myCondition));

System.out.println(myPartedMap);