Java 8 翻转键，使用Java8流的HashMap中的值

我在下面的结构中有一个

映射

，我想翻转键和值

Map<String, List<String>> dataMap

要将此数据转换为

aa: [acct01],
ab: [acct01, acct03],
ac: [acct02],
ad: [acct01, acct02],
ax: [acct03]

想知道是否有Java8流方式来转换地图

我当前在中的实现（无流）

Map originalData=newhashmap（）；
originalData.put（“Acct01”，Arrays.asList（“aa”，“ab”，“ad”））；
originalData.put（“Acct02”，Arrays.asList（“ac”，“ad”）；
originalData.put（“Acct03”，Arrays.asList（“ax”，“ab”）；
System.out.println（原始数据）；
Map newData=newhashmap（）；
originalData.entrySet（）.forEach（条目->{
entry.getValue（）.forEach（v->{
if（newData.get（v）=null）{
List t=new ArrayList（）；
t、 添加（entry.getKey（））；
newData.put（v，t）；
}否则{
newData.get（v.add（entry.getKey（））；
}
});
});
System.out.println（newData）；

投入产出,，

{Acct01=[aa，ab，ad]，Acct02=[ac，ad]，Acct03=[ax，ab]}
{aa=[Acct01]，ab=[Acct01，Acct03]，ac=[Acct02]，ad=[Acct01，Acct02]，ax=[Acct03]}

---

正在寻找使用流实现的方法。

获取条目集的流，将其扁平化为每个键值对的一个条目，按值分组，将关联的键收集到一个列表中

import static java.util.Arrays.asList;
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.mapping;
import static java.util.stream.Collectors.toList;

import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

<K, V> Map<V, List<K>> invert(Map<K, List<V>> map) {
    return map.entrySet().stream().flatMap(
        entry -> entry.getValue().stream().map(
            value -> new SimpleImmutableEntry<>(
                entry.getKey(),
                value
            )
        )
    ).collect(
        groupingBy(
            Entry::getValue,
            mapping(
                Entry::getKey,
                toList()
            )
        )
    );
}

导入静态java.util.Arrays.asList；
导入静态java.util.stream.Collectors.groupingBy；
导入静态java.util.stream.Collectors.mapping；
导入静态java.util.stream.Collectors.toList；
导入java.util.AbstractMap.SimpleImutableEntry；
导入java.util.List；
导入java.util.Map；
导入java.util.Map.Entry；
贴图反转（贴图贴图）{
返回map.entrySet（）.stream（）.flatMap(
entry->entry.getValue（）.stream（）.map(
值->新建SimpleImmutableEntry(
entry.getKey（），
价值
)
)
).收集(
分组依据(
条目：：getValue，
映射(
条目：：getKey，
托利斯特（）
)
)
);
}

以下是Java 8流库的解决方案：

---

您当前的实现已经依赖于Java8的特性。在J8中，

forEach

方法被添加到许多数据结构中，虽然您可以使用流，但这没有任何意义，因为流的许多优点来自于能够以惰性方式执行过滤器、排序和其他方法，这不适用于密钥重新映射

---

如果您真的愿意，您可以通过将示例中的所有

.forEach

实例更改为

.stream（）.forEach

，来加入一些流。

如果您愿意使用第三方库，就像您可以使用a一样（每个键都可以有一个

值列表）。多重映射已经完成。因此，这将起作用：

MutableListMultimap<String, String> originalData = Multimaps.mutable.list.empty();
originalData.putAll("Acct01", Arrays.asList("aa", "ab", "ad"));
originalData.putAll("Acct02", Arrays.asList("ac", "ad"));
originalData.putAll("Acct03", Arrays.asList("ax", "ab"));
System.out.println(originalData);

MutableBagMultimap<String, String> newData = originalData.flip();
System.out.println(newData);

MutableListMultimap originalData=Multimaps.mutable.list.empty（）；
originalData.putAll（“Acct01”，array.asList（“aa”，“ab”，“ad”）；
originalData.putAll（“Acct02”，Arrays.asList（“ac”，“ad”）；
originalData.putAll（“Acct03”，Arrays.asList（“ax”，“ab”）；
System.out.println（原始数据）；
MutableBagMultimap newData=originalData.flip（）；
System.out.println（newData）；

输入：
{Acct03=[ax，ab]，Acct02=[ac，ad]，Acct01=[aa，ab，ad]}

输出：
{ac=[Acct02]，ad=[Acct02，Acct01]，aa=[Acct01]，ab=[Acct03，Acct01]，ax=[Acct03]}

请注意，
flip（）
返回一个值，其中每个键都可以有一个
值包。是一种特殊的数据结构，无序且允许重复

注意：我是Eclipse集合的提交者。
使用传统方式实现。。仍在寻找使用Stream（）实现的方法
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.mapping;
import static java.util.stream.Collectors.toList;

import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

<K, V> Map<V, List<K>> invert(Map<K, List<V>> map) {
    return map.entrySet().stream().flatMap(
        entry -> entry.getValue().stream().map(
            value -> new SimpleImmutableEntry<>(
                entry.getKey(),
                value
            )
        )
    ).collect(
        groupingBy(
            Entry::getValue,
            mapping(
                Entry::getKey,
                toList()
            )
        )
    );
}

newData = EntryStream.of(originalData).invert().flatMapKeys(k -> k.stream()).grouping();

MutableListMultimap<String, String> originalData = Multimaps.mutable.list.empty();
originalData.putAll("Acct01", Arrays.asList("aa", "ab", "ad"));
originalData.putAll("Acct02", Arrays.asList("ac", "ad"));
originalData.putAll("Acct03", Arrays.asList("ax", "ab"));
System.out.println(originalData);

MutableBagMultimap<String, String> newData = originalData.flip();
System.out.println(newData);