使用流的java内部连接

我有两个列表：

命令

[
    {
        item_id=1, 
        item=item-1, 
        user_id=1
    },
    {
        item_id=2, 
        item=item-2, 
        user_id=2
    }, 
    {
        item_id=3, 
        item=item-3, 
        user_id=3
    }
]

使用者

它们初始化为

List<Map<String, String>> data

列表数据

我想使用流在此列表映射上执行sql等效的内部联接

我试过这个：

List<Map<String, String>> collect = leftData.stream().flatMap(t1 -> rightData.stream())
                .filter(t -> t.get(joinColumnTableLeft).equals(t.get(joinColumnTableRight)))
                .collect(Collectors.toList());

List collect=leftData.stream（）.flatMap（t1->righdata.stream（））
.filter（t->t.get（JoinColumntTableLeft）.等于（t.get（JoinColumntTableRight）））
.collect（Collectors.toList（））；

这给了我一个大小（用户）*大小（订单）的结果，即9。 收款人有

订单

但是我想把这两张地图合并成一张，然后从中创建一个列表

---

目前无法使用任何库

假设您没有重复的条目（通过merge列键），您可以使用这样的方法进行合并

这将创建一个

mergeColumn

键映射到其中一个列表中的行完整映射，然后在通过迭代另一个映射进行合并时使用该映射进行查找

static List<Map<String, String>> merge(List<Map<String, String>> left, 
       List<Map<String, String>> right, String joinColumnTableLeft,
       String joinColumnTableRight) {

    Map<String, Map<String, String>> rightById = right.stream()
            .collect(Collectors.toMap(m -> m.get(joinColumnTableRight), 
                                      Function.identity()));

    return left.stream()
               .filter(e -> rightById.containsKey(e.get(joinColumnTableLeft)))
               .map(l -> {
                 Map<String, String> all = new HashMap<>();
                 all.putAll(l);
                 all.putAll(rightById.get(l.get(joinColumnTableLeft)));

                 return all;
               })
               .collect(Collectors.toList());
}

---

它们是如何初始化为列表数据的，你能提供代码吗？从第二个列表创建一个映射。然后遍历第一个列表，对于每个元素，使用映射按用户ID查找用户。您真的应该开始定义类，而不是将数据存储到映射中。@jbnize我知道，但我正在编写一个通用的csv解析器。因此，我必须使用MapsWell，按照我说的做，但使用地图而不是适当的对象。我不太明白这一点/当我在订单中有两次用户id时，我得到了

IllegalStateException:duplicate key

。用户id=3，用户id=3

static List<Map<String, String>> merge(List<Map<String, String>> left, 
       List<Map<String, String>> right, String joinColumnTableLeft,
       String joinColumnTableRight) {

    Map<String, Map<String, String>> rightById = right.stream()
            .collect(Collectors.toMap(m -> m.get(joinColumnTableRight), 
                                      Function.identity()));

    return left.stream()
               .filter(e -> rightById.containsKey(e.get(joinColumnTableLeft)))
               .map(l -> {
                 Map<String, String> all = new HashMap<>();
                 all.putAll(l);
                 all.putAll(rightById.get(l.get(joinColumnTableLeft)));

                 return all;
               })
               .collect(Collectors.toList());
}

Map<String, String> left1 = new HashMap<>(), right1 = new HashMap<>();
left1.put("a", "A");
left1.put("b", "B");
left1.put("c", "C");

right1.put("a", "A");
right1.put("d", "B");

Map<String, String> left2 = new HashMap<>(), right2 = new HashMap<>();
left2.put("a", "AA");
left2.put("b", "BB");
left2.put("c", "CC");

right2.put("a", "AA");
right2.put("d", "BB");

System.out.println(merge(Arrays.asList(left1, left2), 
        Arrays.asList(right1, right2), "a", "a"));

static List<Map<String, String>> merge(List<Map<String, String>> left, 
        List<Map<String, String>> right,
        String joinColumnTableLeft, String joinColumnTableRight) {

    Map<String, List<Map<String, String>>> rightById = right.stream()
            .collect(Collectors.groupingBy(m -> m.get(joinColumnTableRight)));

    return left.stream()
            .filter(e -> rightById.containsKey(e.get(joinColumnTableLeft)))
            .flatMap(l -> rightById.get(l.get(joinColumnTableLeft)).stream()
                    .map(r -> {
                                Map<String, String> all = new HashMap<>();
                                all.putAll(l);
                                all.putAll(r);

                                return all;
                            }
                    )
    ).collect(Collectors.toList());
}