在Java8中用嵌套数据结构实现映射的功能倒置

Question

我有一个问题现在快把我逼疯了。我试图避免为这个映射反转创建一个中间对象。（目标：我有一个带有嵌套数据结构的映射，我想对其进行反转和爆炸。所以，

Map<Foo,Set<String>> fooStringMap

变成

Map<String,Foo> expandedStringFooMap

//Inverting a map is simple
private <X,Y> Map<Y,X> invertMap(Map<X,Y> source){
    return source.entrySet().stream()
                            .collect(Collectors.toMap(Entry::getValue,Entry::getKey)

private <A,B> Map<A,B> explodeMapWithCollection(Map<? extends Collection<A>, B> collectionMap){
 collectionMap.entrySet().stream()
            .flatMap(x -> x.getKey().stream().collect(Collectors.toMap(Function.identity(),x.getValue())))
            .collect(Collectors.toMap(Entry::getKey,Entry::getValue));
}

目前，这不起作用。我甚至不认为上面会编译，所以就当它是伪代码吧。

someMap.keySet().stream().flatMap(key->someMap.get(key).stream().map(val -> new 
Pair<>(val,key))).collect(Collectors.toMap(Pair::getLeft,Pair::getRight)));

Answer 1

下面是一种在条目集上使用自定义流#collect的方法。有人可能会争辩说，由于隐藏在累加器中的foreach，这并不是“完全有效的”，但是在某些时候，必须创建映射条目，我不确定是否有一种“优雅的”方法来使用set的流（条目值），并且仍然有可能访问条目键（它将成为新条目的值）。

一个附带说明（尽管我拿起棍棒进行过程性编程，冒着被否决的风险）：您不必仅仅因为可以就用函数式的方式来完成它。当你说你“迷失在语法中”，那么

1. 几周后再次阅读此代码时，您会怎么想？
2. 当你的同事第一次读这段代码时会怎么想？（我担心的是那个带着电锯和守门员面具的...）

import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class MapInvert
{
    public static void main(String[] args)
    {
        Map<Integer, Set<String>> map = 
            new LinkedHashMap<Integer, Set<String>>();

        map.put(1, new LinkedHashSet<String>(Arrays.asList("A","B","C")));
        map.put(2, new LinkedHashSet<String>(Arrays.asList("D","E","F")));
        map.put(3, new LinkedHashSet<String>(Arrays.asList("G","H","I")));

        Map<String, Integer> resultA = inverseEx(map);
        System.out.println("Procedural: "+resultA);

        Map<String, Integer> resultB = map.entrySet().stream().collect(
            LinkedHashMap::new, 
            (m, e) -> e.getValue().forEach(v -> m.put(v, e.getKey())), 
            (m0, m1) -> m0.putAll(m1));
        System.out.println("Functional: "+resultB);
    }

    /**
     * Invert the given map, by mapping each element of the values to
     * the respective key
     *  
     * @param map The input map
     * @return The inverted map
     */
    private static <K, V> Map<V, K> inverseEx(
        Map<K, ? extends Collection<? extends V>> map)
    {
        Map<V, K> result = new LinkedHashMap<V, K>();
        for (Entry<K, ? extends Collection<? extends V>> e : map.entrySet())
        {
            for (V v : e.getValue())
            {
                result.put(v, e.getKey());
            }
        }
        return result;
    }
}