Collectors.groupingBy on a Map Result to Nested Map

user_1450401 0
Viewed 401

I have following code

 Map<Long,String> timeMap= new HashMap<>();
    Map<Boolean, List<Map.Entry<Long,String>>> output= timeMap.entrySet().parallelStream()
            .filter(map -> map.getKey()-Instant.now().toEpochMilli()>120000)
            .collect(Collectors.groupingBy(o -> o.getKey()<600000));

I want my output to be a map nested map

 Map<Boolean, List<Map.Entry<Long,String>>> output --> Map<Boolean, Map<Long,String>> output

Could someone help me to write a BiFunction to achieve this.

Currently I'm using following approach to generate the output.

 Map<Long, String> trueMap = output.get(true).stream()
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    Map<Long, String> falseMap = output.get(false).stream()
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

    Map<Boolean,Map<Long,String>>  booleanMapMap = new HashMap<>();
    booleanMapMap.put(true,trueMap);
    booleanMapMap.put(false,falseMap);
java-8 grouping lambda
2 Answers

A nested Collector would be a better approach:

Map<Boolean, Map<Long, String>> collect = timeMap.entrySet().stream()
    .filter(e -> e.getKey() - Instant.now().toEpochMilli() > 120_000)
    .collect(
        Collectors.partitioningBy(e -> e.getKey() < 600_000, 
            Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)
        ));
user_41054570

Here's a way without streams:

Map<Boolean, Map<Long, String>> booleanMapMap = new HashMap<>();
timeMap.forEach((k, v) -> {
    if (k - Instant.now().toEpochMilli() > 120_000)
        booleanMapMap.computeIfAbsent(k < 600_000, dummy -> new HashMap<>()).put(k, v);
});

In order to avoid NPE, you should retrieve from the outer map as follows:

Map<Long, String> trueMap = booleanMapMap.getOrDefault(true, new HashMap<>());

If you want to keep entries in insertion order, just change dummy -> new HashMap<>() by dummy -> new LinkedHashMap<>().

user_18766200
Related