使用流过滤java中的内部和外部列表

Question

有没有一种方法可以使用一些谓词和java流来过滤内部和外部列表？例如：

Class outerObject{
    int num;
    List<innerObject> innerObjectList;
}
Class innerObject{
    int num;
}
List <outerObject> outerObjectList

是否有一种方法可以过滤列表，使得outerObject列表具有字段num=10，并且相应的outerObject的innerObject列表也会被相应的字段num=10过滤？

我试过：

outerObjectList.stream()
               .filter(i -> i.getNum() == 10)
               .filter(i -> i.getOrders().stream().anyMatch(s -> getNum() == 10))
               .collect(Collectors.toList());

但它似乎无法过滤内部列表。

描述性示例：

如果一个外部列表有3个具有num=10的对象，并且3个对象中的每一个都有1个内部对象在它们的innerObjectList中具有num=10，那么它应该给我一个包含3个outerObject< /code>的列表，每个列表包含1个innerObject。




Answer 1

当你在流的上下文中说“filter”时，通常意味着过滤流，以便下游操作看到流的子集。我想你真正想要的是根据条件从列表中删除项目。您可以使用“窥视”操作来完成此操作：

public class Outer {

    private final int num;
    private final List<Inner> inners = new ArrayList<>();

    public class Inner {

        private final int num;

        public Inner(int num) {
            this.num = num;
        }

        public boolean hasNum(int num) {
            return this.num == num;
        }
    }

    public Outer(int num) {
        this.num = num;
    }

    public void addInner(int num) {
        inners.add(new Inner(num));
    }

    public void removeInners(int num) {
        inners.removeIf(i -> i.hasNum(num));
    }

    public boolean hasInner(int num) {
        return inners.stream().anyMatch(i -> i.hasNum(num));
    }

    public boolean hasNum(int num) {
        return this.num == num;
    }
}

@Test
public void testOuter() {
    List<Outer> outers = new ArrayList<>();
    outers.add(new Outer(1));
    outers.add(new Outer(1));
    outers.get(1).addInner(5);
    outers.get(1).addInner(1);
    outers.add(new Outer(2));
    outers.add(new Outer(1));
    outers.get(3).addInner(1);
    outers = outers.stream()
            .filter(o -> o.hasNum(1))
            .peek(o -> o.removeInners(1))
            .collect(Collectors.toList());
    assertThat(outers.size(), is(2));
    assertFalse(outer.stream().anyMatch(i -> i.hasInner(1)));
}

请注意，我将在收集列表后将其分配回变量。

Answer 2

如果要修改现有列表（而不是创建新列表），可以使用Collection。移除方法：

outerObjectList.removeIf(i -> i.getNum() != 10);
outerObjectList.forEach(i -> i.getOrders().removeIf(s -> s.getNum() != 10));

此操作不需要流API。

Answer 3

它没有过滤内部列表，因为在任何时候都不会更改任何元素；你只是从顶级列表中删除它们。

为了过滤内部列表，您应该有一个. map操作来操作外部对象，将它们更改为新的外部对象，其内部对象列表本身就是旧列表的过滤版本。

outerObjectList.stream()
                .filter(i -> i.getNum() == 10)
              .filter(i -> i.getOrders().stream().anyMatch(s -> getNum() == 10))
                .collect(Collectors.toList());

让我们把它分解一下：你有两条溪流，外部流（在其上调用.filter、.filter和.collect）和内部流（在其上调用.anyMatch）。最终得到的只是外部流的集合，并且在任何时候都不能修改其任何成员（仅通过删除它们来修改流本身的结构）你根本不修改内部流；您只需报告它的一个特性（“它是否具有getNum（）==10？”）

如果你想过滤内部流，你有更多的工作要做。实际上，您可以使用修改外部流的元素。peek，将其列表更改为“过滤”版本；或者，如果你想保持良好和不变，你可以用创建新的过滤版本。地图。

对于。map（）approach，你需要一个lambda来创建一个新的OuterObject，这样：

• 输出。num==输入。num
• 输出。innerObjectList==输入。innerObjectList。stream（）。过滤器-

这有意义吗？