java - 如何从两个不同对象的列表中获取不常见的对象

Question

我有两个列表

List<Foo> foolist = getAll();
List<Bar> barList = getAll();

class Foo {
    String name;
    String age;
    ....
    // more fields
}

class Bar {
    String barName;
    int codeBar;
    ....
    // more field
}

我们可以用age<->codeBar和name<->barName建立它们之间的关系我想要得到不傻的 Bar 对象，如何使用流来完成？

我看到使用stream().filter(list::contains)的示例，但在这种情况下它无效。

有人能指出我正确的方向吗？

谢谢大家。我正在寻找这样的东西: barList.stream().filter(b->fooList.stream().anyMatch(f->!b.getBarName().equalsIgnoreCase(f.getName) && b.getCodeBar() == Integer.valueOf(age))).collect(Collectors.toList());

还不知道对不对

Answer 1

你可以这样做:

public static void main(String[] args) {
    List<Foo> fooList = asList(new Foo("1", "1"), new Foo("2", "2"), new Foo("3", "3"));
    List<Bar> barList = asList(new Bar("4", 4), new Bar("3", 3), new Bar("5", 5));

    Set<Blah> fooSet = fooList.stream().map(Main::fooToBlah).collect(toCollection(HashSet::new));
    Set<Blah> barSet = barList.stream().map(Main::barToBlah).collect(toCollection(HashSet::new));

    barList.stream()
            .filter(bar -> !fooSet.contains(barToBlah(bar)))
            .forEach(System.out::println);
    fooList.stream()
            .filter(foo -> !barSet.contains(fooToBlah(foo)))
            .forEach(System.out::println);
}

static Blah fooToBlah(Foo foo) {
    return new Blah(foo.name, foo.age);
}

static Blah barToBlah(Bar bar) {
    return new Blah(bar.barName, "" + bar.codeBar);
}

static class Blah {
    String name;
    String age;

    public Blah(String name, String age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        ...
    }

    @Override
    public int hashCode() {
        ...
    }
}

1. 全部取 Foo对象并将其转换为Blah (当然要适本地命名) - 这是需要的，因为 Foo还有其他我们不关心的字段。
2. 输入Blah对象进入 HashSet这样你就不会得到 O(n*m)时间复杂度。你可以这样做collect(toSet()) ，但我更愿意在这里明确说明，因为它对性能很重要。
3. 查看Bar对象，如果一个对象不在上面的集合中，那就是不常见的 Bar目的。需要转换为Blah不幸的是你不能使用 Stream.map最后它应该仍然是 Stream<Bar> ，不是Stream<Blah> .
4. 对其他列表重复上述三个步骤以查找所有不常见的 Foo对象。

请记住equals和hashCode Blah 需要方法类(class)。 Foo和Bar类不需要它们。

<小时/>

编辑:

您可以转换以下代码

Set<Blah> fooSet = fooList.stream().map(Main::fooToBlah).collect(toCollection(HashSet::new));

barList.stream()
        .filter(bar -> !fooSet.contains(barToBlah(bar)))
        .forEach(System.out::println);

变成这样的东西

barList.stream()
        .filter(bar -> fooList.stream()
                .map(Main::fooToBlah)
                .noneMatch(foo -> foo.equals(barToBlah(bar)))
        )
        .forEach(System.out::println);

甚至删除 Blah完全上课

barList.stream()
        .filter(bar -> fooList.stream().noneMatch(foo -> Objects.equals(foo.name, bar.barName) && Objects.equals(foo.age, "" + bar.codeBar)
        .forEach(System.out::println);

但是你最终会得到更糟糕的时间复杂度，并且还存在可读性问题。