使用流在Java中进行内部联接

Question

我有两个列表图：

命令

[
    {
        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
    }
]

使用者

[
    {
        user_id=1, 
        name=abh, 
        email=abh@bit.com
    }, 
    {
        user_id=2, 
        name=pol, 
        email=pol@bit.com
    }, 
    {
        user_id=3, 
        name=tre, 
        email=tre@bit.com
    }
]

它们被初始化为

List<Map<String, String>> data

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

我尝试了这个：

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

这给我的结果是size size（users）* size（orders）为9 orders。

但是我希望将两个Map合并为一个，然后从中创建一个列表。

目前无法使用任何库。

Answer 1

假设您没有重复的条目（通过合并列键），则可以使用类似的方法进行合并。

这会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());
}

作为测试：

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"));

输出为： [{a=A, b=B, c=C, d=B}, {a=AA, b=BB, c=CC, d=BB}]

条目的顺序并不重要。请注意，这假设除了join列外没有重叠的键。否则，您可能希望收集地图对，而不是调用putAll新地图。

以下将支持重复的联接键（并将为每个键的所有条目产生笛卡尔乘积）：

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());
}