Java 8 拉姆达 Map<string, string> 至 Map <string, map<string, long> &gt;</string,></string,>

Question

I have a service that returns a response and maps it to a Map<String, String> object

After this I need to calculate the key of the new map and insert as well all the keys that appear plus how many times they do.

They key is calculated by getting the first character of the associated string.

Key: A -> August/Air

Key: B -> Boat/Big

Example:

Service response:

{
    {
        "august",
        "red"
    },
    {
        "air",
        "red"
    },
    {
        "boat",
        "blue"
    },
    {
        "big",
        "red"
    }
}

Expected output:

{
    "a" : {
        "red" : 2
    },

    "b" : {
        "blue" : 1,
        "red": 1
    }
}

I did this already in Java 7 but I would like to apply lambdas to this.

Map<String, Map<String, AtomicLong>> map = new HashMap<>();

String key = ...
String value = ...

Response.incrementCount(key, value);

map.put(key, Response.count.get(key));

Response.java

public static Map<String, Map<String, AtomicLong>> count = new HashMap<>();

public static void incrementCount(String key, String value) {
    count.computeIfAbsent(key, k -> new HashMap<>());

    AtomicLong actual = count.get(key).get(value);
    Map<String, AtomicLong> stringAtomicLongMap = count.get(key);
    if (null == actual) {
        actual = new AtomicLong();
        stringAtomicLongMap.put(value, actual);
        count.put(key, stringAtomicLongMap);
    }
    actual.incrementAndGet();
}

Answer 1

Existing Map<String, String> map should be converted this way:

1. Group by the first character of key
2. For values, group by value and count frequency

static Map<String, Map<String, Long>> convert(Map<String, String> map) {
    return map.entrySet()
            .stream()
            .collect(Collectors.groupingBy(
                e -> e.getKey().substring(0, 1),
                LinkedHashMap::new, // (optionally) use to keep insertion order
                Collectors.groupingBy(
                    Map.Entry::getValue, Collectors.counting()
                )
            ));
}

Test:

Map<String, String> map = Map.of(
    "august", "red",
    "air", "red",
    "boat", "blue",
    "big", "red"
);
Map<String, Map<String, Long>> result = convert(map);
    
result.forEach((k, v) -> System.out.printf("'%s': %s%n", k, v));

Output:

'a': {red=2}
'b': {red=1, blue=1}

Answer 2

Here is solution using Stream API:

Map<String, Map<String, Long>> resultMap = map.entrySet().stream()
    .map(entry -> {
        String firstChar = entry.getKey().substring(0, 1);
        return new AbstractMap.SimpleEntry<>(firstChar, entry.getValue());
    })
    .collect(Collectors.groupingBy(
        Map.Entry::getKey,
        Collectors.groupingBy(Map.Entry::getValue, Collectors.counting())
    ));

What is actually happening:

• Given entry is changed to have only the first char (but as String) to be they key of entry
• Such entries are grouped by the key (first char)
• If there are multiple values by this key - they are grouped by the entry value - and counting such values