java中地图对象的联接列表

有两个映射列表，应该在这两个列表上进行数据集连接，leftJoin、rightJoin、outerJoin和innerJoin

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

public class JoinMap {
    public static List<Map<String, Object>> getFirstMap() {
        List<Map<String,  Object>> data = new ArrayList<>();
        Map<String,  Object> dataMap2 = new HashMap<>();
        dataMap2.put("user", "vs");
        dataMap2.put("data1", 12.0);
        dataMap2.put("data2", 42.0);
        dataMap2.put("data3", 32.0);
        data.add(dataMap2);
        Map<String,  Object> dataMap1 = new HashMap<>();
        dataMap1.put("user", "samraj");
        dataMap1.put("data1", 11.0);
        dataMap1.put("data2", 41.0);
        dataMap1.put("data3", 31.0);
        data.add(dataMap1);
        Map<String,  Object> dataMap = new HashMap<>();
        dataMap.put("user", "varghees");
        dataMap.put("data1", 10.0);
        dataMap.put("data2", 40.0);
        dataMap.put("data3", 30.0);
        data.add(dataMap);
        return data;
    }

    public static List<Map<String, Object>> getSecondMap() {
        List<Map<String,  Object>> data = new ArrayList<>();
        Map<String,  Object> dataMap2 = new HashMap<>();
        dataMap2.put("user", "vs");
        dataMap2.put("test1", 12.0);
        dataMap2.put("test2", 42.0);
        dataMap2.put("test3", 32.0);
        data.add(dataMap2);
        Map<String,  Object> dataMap1 = new HashMap<>();
        dataMap1.put("user", "samraj");
        dataMap1.put("test1", 11.0);
        dataMap1.put("test2", 41.0);
        dataMap1.put("test3", 31.0);
        data.add(dataMap1);
        Map<String,  Object> dataMap = new HashMap<>();
        dataMap.put("user", "varghees");
        dataMap.put("test1", 10.0);
        dataMap.put("test2", 40.0);
        dataMap.put("test3", 30.0);
        data.add(dataMap);
        return data;
    }

    public static List<Map<String, Object>> leftJoin(List<Map<String, Object>> map1, List<Map<String, Object>> map2) {

    }
    public static List<Map<String, Object>> rightJoin(List<Map<String, Object>> map1, List<Map<String, Object>> map2) {

    }
    public static List<Map<String, Object>> innerJoin(List<Map<String, Object>> map1, List<Map<String, Object>> map2) {

    }
    public static List<Map<String, Object>> outerJoin(List<Map<String, Object>> map1, List<Map<String, Object>> map2) {

    }

    public static void main(String[] argv) {
        List<Map<String, Object>> firstMap = getFirstMap();
        List<Map<String, Object>> secondMap = getSecondMap();
    }
}

import java.util.ArrayList；
导入java.util.List；
导入java.util.Map；
导入java.util.HashMap；
公共类JoinMap{
公共静态列表getFirstMap（）{
列表数据=新的ArrayList（）；
Map dataMap2=新的HashMap（）；
dataMap2.put（“用户”、“vs”）；
dataMap2.put（“data1”，12.0）；
dataMap2.put（“data2”，42.0）；
dataMap2.put（“data3”，32.0）；
data.add（dataMap2）；
Map dataMap1=新的HashMap（）；
dataMap1.put（“用户”、“samraj”）；
dataMap1.put（“data1”，11.0）；
dataMap1.put（“data2”，41.0）；
dataMap1.put（“data3”，31.0）；
data.add（dataMap1）；
Map dataMap=newhashmap（）；
dataMap.put（“用户”、“varghees”）；
dataMap.put（“data1”，10.0）；
dataMap.put（“data2”，40.0）；
dataMap.put（“data3”，30.0）；
data.add（dataMap）；
返回数据；
}
公共静态列表getSecondMap（）{
列表数据=新的ArrayList（）；
Map dataMap2=新的HashMap（）；
dataMap2.put（“用户”、“vs”）；
dataMap2.put（“test1”，12.0）；
dataMap2.put（“test2”，42.0）；
dataMap2.put（“test3”，32.0）；
data.add（dataMap2）；
Map dataMap1=新的HashMap（）；
dataMap1.put（“用户”、“samraj”）；
dataMap1.put（“test1”，11.0）；
dataMap1.put（“test2”，41.0）；
dataMap1.put（“test3”，31.0）；
data.add（dataMap1）；
Map dataMap=newhashmap（）；
dataMap.put（“用户”、“varghees”）；
dataMap.put（“test1”，10.0）；
dataMap.put（“test2”，40.0）；
dataMap.put（“test3”，30.0）；
data.add（dataMap）；
返回数据；
}
公共静态列表leftJoin（列表map1、列表map2）{
}
公共静态列表rightJoin（列表映射1、列表映射2）{
}
公共静态列表innerJoin（列表map1、列表map2）{
}
公共静态列表外部连接（列表map1、列表map2）{
}
公共静态void main（字符串[]argv）{
List firstMap=getFirstMap（）；
List secondMap=getSecondMap（）；
}
}

---

Java8中有没有简单的函数来实现这些方法？我试图避免重复数据并填充新的数据集。

当然有。下面是一个使用流进行内部连接的示例。我假设我们知道一个事实，那就是我们应该加入

“user”

（如果不是，它会变得更复杂，但仍然可以做到）

公共静态列表innerJoin（列表map1、列表map2）{
返回map1.stream（）.flatMap（m1->
map2.stream（）
.filter（m2->m1.get（“用户”）.equals（m2.get（“用户”））
.地图（（地图m2）->{
Map mr=新的HashMap（）；
普托尔先生（m1）；
普托尔先生（m2）；
返回mr；
})
).collect（Collectors.toList（））；
}

---

我希望并认为你能从中汲取灵感，自己做其他事情。

当然有。下面是一个使用流进行内部连接的示例。我假设我们知道一个事实，那就是我们应该加入

“user”

（如果不是，它会变得更复杂，但仍然可以做到）

公共静态列表innerJoin（列表map1、列表map2）{
返回map1.stream（）.flatMap（m1->
map2.stream（）
.filter（m2->m1.get（“用户”）.equals（m2.get（“用户”））
.地图（（地图m2）->{
Map mr=新的HashMap（）；
普托尔先生（m1）；
普托尔先生（m2）；
返回mr；
})
).collect（Collectors.toList（））；
}

---

我希望并认为你能从中获得灵感，自己做其他事情。

是的，这很好，很有效。如果我们能够修复其他函数，我会将其标记为解决方案是的，这很好而且有效。如果我们能够修复其他函数，我会将其标记为解决方案

public static List<Map<String, Object>> innerJoin(List<Map<String, Object>> map1, List<Map<String, Object>> map2) {
    return map1.stream().flatMap(m1 -> 
        map2.stream()
                .filter(m2 -> m1.get("user").equals(m2.get("user")))
                .map((Map<String, Object> m2) -> {
                    Map<String, Object> mr = new HashMap<>();
                    mr.putAll(m1);
                    mr.putAll(m2);
                    return mr;
                })
    ).collect(Collectors.toList());
}