Java 地图上的复杂操作问题

假设我有以下两张地图：

Map<Member, List<Message>> one = ...;//one constructed somehow
Map<Member, List<Message>> two = ...;//two also constructed somehow

Map one=//不知何故建造的
映射二=//两个也以某种方式构建

我想获得第三张包含one和two内容的地图

因此，如果成员键同时位于1和2中，则2中条目的列表值将添加到1中条目的列表值中

---

使用java 8实现这一点的最佳和最干净的方法是什么？

您可以使用合并方法

Map<Member, List<Message>> third = new HashMap<>(one);
two.forEach((k, v) -> third.merge(k, v, (v1, v2) -> {v1.addAll(v2); return v1;}));

合并后的列表将是一个新列表，但请注意，对于不在两个贴图中的键，情况并非如此。要实现这一点，您需要深入复制所有列表

刚刚使用Stream API添加了另一个解决方案：

Map<Member, List<Message>> third = Stream.of(one, two)
                                         .flatMap(m -> m.entrySet().stream())
                                         .collect(toMap(Map.Entry::getKey, 
                                                        Map.Entry::getValue, 
                                                        (l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(toList())));

Map third=Stream.of（一，二）
.flatMap（m->m.entrySet（）.stream（））
.collect（toMap）（Map.Entry:：getKey，
Map.Entry:：getValue，
（l1，l2）->Stream.concat（l1.Stream（），l2.Stream（））.collect（toList（））；

我还将我的贡献添加到了。有了这一点，您也可以这样实现：

Map<Member, List<Message>> third = new HashMap<>(one);
two.forEach((k, v) -> third.merge(k, v, (v1, v2) -> Stream.concat(v1.stream(), v2.stream()).collect(toList())));

Map<Member, List<Message>> third = MapStream.ofMaps(one, two)
                                            .mergeKeys((l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(toList()))
                                            .collect();

Map third=MapStream.ofmap（一、二）
.mergeKeys（（l1，l2）->Stream.concat（l1.Stream（），l2.Stream（））.collect（toList（））
.收集（）；

您可以使用合并方法

Map<Member, List<Message>> third = new HashMap<>(one);
two.forEach((k, v) -> third.merge(k, v, (v1, v2) -> {v1.addAll(v2); return v1;}));

合并后的列表将是一个新列表，但请注意，对于不在两个贴图中的键，情况并非如此。要实现这一点，您需要深入复制所有列表

刚刚使用Stream API添加了另一个解决方案：

Map<Member, List<Message>> third = Stream.of(one, two)
                                         .flatMap(m -> m.entrySet().stream())
                                         .collect(toMap(Map.Entry::getKey, 
                                                        Map.Entry::getValue, 
                                                        (l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(toList())));

Map third=Stream.of（一，二）
.flatMap（m->m.entrySet（）.stream（））
.collect（toMap）（Map.Entry:：getKey，
Map.Entry:：getValue，
（l1，l2）->Stream.concat（l1.Stream（），l2.Stream（））.collect（toList（））；

我还将我的贡献添加到了。有了这一点，您也可以这样实现：

Map<Member, List<Message>> third = new HashMap<>(one);
two.forEach((k, v) -> third.merge(k, v, (v1, v2) -> Stream.concat(v1.stream(), v2.stream()).collect(toList())));

Map<Member, List<Message>> third = MapStream.ofMaps(one, two)
                                            .mergeKeys((l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(toList()))
                                            .collect();

Map third=MapStream.ofmap（一、二）
.mergeKeys（（l1，l2）->Stream.concat（l1.Stream（），l2.Stream（））.collect（toList（））
.收集（）；

您可以使用合并方法

Map<Member, List<Message>> third = new HashMap<>(one);
two.forEach((k, v) -> third.merge(k, v, (v1, v2) -> {v1.addAll(v2); return v1;}));

合并后的列表将是一个新列表，但请注意，对于不在两个贴图中的键，情况并非如此。要实现这一点，您需要深入复制所有列表

刚刚使用Stream API添加了另一个解决方案：

Map<Member, List<Message>> third = Stream.of(one, two)
                                         .flatMap(m -> m.entrySet().stream())
                                         .collect(toMap(Map.Entry::getKey, 
                                                        Map.Entry::getValue, 
                                                        (l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(toList())));

Map third=Stream.of（一，二）
.flatMap（m->m.entrySet（）.stream（））
.collect（toMap）（Map.Entry:：getKey，
Map.Entry:：getValue，
（l1，l2）->Stream.concat（l1.Stream（），l2.Stream（））.collect（toList（））；

我还将我的贡献添加到了。有了这一点，您也可以这样实现：

Map<Member, List<Message>> third = new HashMap<>(one);
two.forEach((k, v) -> third.merge(k, v, (v1, v2) -> Stream.concat(v1.stream(), v2.stream()).collect(toList())));

Map<Member, List<Message>> third = MapStream.ofMaps(one, two)
                                            .mergeKeys((l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(toList()))
                                            .collect();

Map third=MapStream.ofmap（一、二）
.mergeKeys（（l1，l2）->Stream.concat（l1.Stream（），l2.Stream（））.collect（toList（））
.收集（）；

您可以使用合并方法

Map<Member, List<Message>> third = new HashMap<>(one);
two.forEach((k, v) -> third.merge(k, v, (v1, v2) -> {v1.addAll(v2); return v1;}));

合并后的列表将是一个新列表，但请注意，对于不在两个贴图中的键，情况并非如此。要实现这一点，您需要深入复制所有列表

刚刚使用Stream API添加了另一个解决方案：

Map<Member, List<Message>> third = Stream.of(one, two)
                                         .flatMap(m -> m.entrySet().stream())
                                         .collect(toMap(Map.Entry::getKey, 
                                                        Map.Entry::getValue, 
                                                        (l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(toList())));

Map third=Stream.of（一，二）
.flatMap（m->m.entrySet（）.stream（））
.collect（toMap）（Map.Entry:：getKey，
Map.Entry:：getValue，
（l1，l2）->Stream.concat（l1.Stream（），l2.Stream（））.collect（toList（））；

我还将我的贡献添加到了。有了这一点，您也可以这样实现：

Map<Member, List<Message>> third = new HashMap<>(one);
two.forEach((k, v) -> third.merge(k, v, (v1, v2) -> Stream.concat(v1.stream(), v2.stream()).collect(toList())));

Map<Member, List<Message>> third = MapStream.ofMaps(one, two)
                                            .mergeKeys((l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(toList()))
                                            .collect();

Map third=MapStream.ofmap（一、二）
.mergeKeys（（l1，l2）->Stream.concat（l1.Stream（），l2.Stream（））.collect（toList（））
.收集（）；