如何在Java 8中组合/合并两个列表映射（映射<；字符串、映射<；枚举、列表<；字符串>；）

鉴于： 包含水果的地图

enum Food{
FRUITS, VEGGIES;
}

Map<String, Map<Food, List<String>>> fruitBasket= new HashMap<>();
fruitBasket.put("basket1", Collections.singletonMap(Food.FRUITS, Arrays.asList("apple","banana")));
fruitBasket.put("basket2", Collections.singletonMap(Food.FRUITS, Arrays.asList"orange", "kiwi")));
fruitBasket.put("basket3", Collections.singletonMap(Food.FRUITS, Arrays.asList("banana", "orange")));

fruitBasket:
[
basket1, [Food.FRUITS, {"apple", "banana"}],
basket2, [Food.FRUITS, {"orange", "kiwi"}],
basket3, [Food.FRUITS, {"banana", "orange"}]
]

我的解决方案：

Solution 1:
Map<String, Map<Food, List<String>>> groceryBasket= new HashMap<>();

grocery basket = Stream.concat(fruitBasket.entrySet().stream(), veggieBasket.entrySet().stream())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (fruitList, veggieList ) ->
                {
                    final List<String> groceryList = new ArrayList<>();
                    groceryList .addAll(fruitList);
                    groceryList .addAll(veggieList);
                    return groceryList;
                }));

Solution 2:
Map<String, Map<Food, List<String>>> groceryBasket= new HashMap<>();

grocery basket = Stream.concat(fruitBasket.entrySet().stream(), veggieBasket.entrySet().stream())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (fruitList, veggieList ) ->
                {
                    return Stream.of(fruitList, veggieList).flatMap(x -> x.stream()).collect(Collectors.toList());
                }));

解决方案1：
Map groceryBasket=newhashmap（）；
杂货篮=Stream.concat（fruitBasket.entrySet（）.Stream（），vegiebasket.entrySet（）.Stream（））
.collect（Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue，（水果列表，蔬菜列表）->
{
最终列表groceryList=新的ArrayList（）；
杂货店名录（水果名录）；
杂货店名录（蔬菜名录）；
退货杂货店；
}));
解决方案2：
Map groceryBasket=newhashmap（）；
杂货篮=Stream.concat（fruitBasket.entrySet（）.Stream（），vegiebasket.entrySet（）.Stream（））
.collect（Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue，（水果列表，蔬菜列表）->
{
返回Stream.of（水果列表，蔬菜列表）.flatMap（x->x.Stream（））.collect（Collectors.toList（））；
}));

---

我尝试了解决方案1和解决方案2，我想知道是否有更好的/优化的方法来处理此问题？

为什么不尝试将合并解析为：

Map<String, Map<Food, List<String>>> groceryBasket =
        Stream.concat(fruitBasket.entrySet().stream(), veggieBasket.entrySet().stream())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> {
                    Map<Food, List<String>> innerMap = new HashMap<>(a);
                    innerMap.putAll(b);
                    return innerMap;
                }));

Map groceryBasket=
Stream.concat（fruitBasket.entrySet（）.Stream（），vegiebasket.entrySet（）.Stream（））
.collect（Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue，（a，b）->{
Map innerMap=新的HashMap（a）；
innerMap.putAll（b）；
返回内部映射；
}));

或者，如果内部映射是可变的，那么

Map<String, Map<Food, List<String>>> groceryBasket = Stream.concat(fruitBasket.entrySet().stream(),
        veggieBasket.entrySet().stream())
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> {
            a.putAll(b);
            return a;
        }));

Map groceryBasket=Stream.concat（fruitBasket.entrySet（）.Stream（），
vegiebasket.entrySet（）.stream（））
.collect（Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue，（a，b）->{
a、 普塔尔（b）；
返回a；
}));

您必须创建可修改列表以合并重复密钥

Stream.concat(fruitBasket.entrySet().stream(), veggieBasket.entrySet().stream())
                .collect(Collectors.toMap(Map.Entry::getKey, e -> listOf(e.getValue()),
                        (left, right) -> {
                            left.addAll(right);
                            return left;
                        }));

要创建可修改列表

public static List<Map<Food, List<String>>> listOf(Map<Food, List<String>> a) {
    final ArrayList<Map<Food, List<String>>> list = new ArrayList<>();
    list.add(a);
    return list;
}

公共静态列表列表（映射a）{
最终ArrayList=新ArrayList（）；
列表.添加（a）；
退货清单；
}

输出：

{basket3=[{水果=[香蕉，橙子]}，{蔬菜=[土豆，番茄]}

篮子2=[{水果=[橘子，猕猴桃]}，{蔬菜=[洋葱，土豆]}

篮子1=[{水果=[苹果，香蕉]}，{蔬菜=[番茄，洋葱]}

您可以这样做：

Map<String, Map<Food, List<String>>> groceryBasket = 
   Stream.concat(fruitBasket.entrySet().stream(),veggieBasket.entrySet().stream())
       .collect(Collectors.toMap(Map.Entry::getKey, v -> v.getValue().entrySet().stream()
                   .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)),
                    (a, b) -> { a.putAll(b);return a; }
                   )
               );

Map groceryBasket=
Stream.concat（fruitBasket.entrySet（）.Stream（），vegiebasket.entrySet（）.Stream（））
.collect（Collectors.toMap（Map.Entry:：getKey，v->v.getValue（）.entrySet（）.stream（））
.collect（Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue）），
（a，b）->{a.putAll（b）；返回a；}
)
);

您的解决方案的返回类型是什么？因为它是一个

singletonMap-不可变的

@HadiJ correct，在答案中编辑。谢谢你指出。

public static List<Map<Food, List<String>>> listOf(Map<Food, List<String>> a) {
    final ArrayList<Map<Food, List<String>>> list = new ArrayList<>();
    list.add(a);
    return list;
}

Map<String, Map<Food, List<String>>> groceryBasket = 
   Stream.concat(fruitBasket.entrySet().stream(),veggieBasket.entrySet().stream())
       .collect(Collectors.toMap(Map.Entry::getKey, v -> v.getValue().entrySet().stream()
                   .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)),
                    (a, b) -> { a.putAll(b);return a; }
                   )
               );