使用流过滤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 个对象中的每一个在它们的 innerObjectList 中有 1 个带有 num = 10 的内部对象，那么它应该给我一个列表 3 outerObject 和一个列表 1 innerObject每个。

Answer 1

如果您想就地修改列表（不创建新列表），可以使用Collection.removeIf 方法：

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

此操作不需要 Stream API。

Answer 2

它不会过滤内部列表，因为您绝不会更改任何元素；您只是将它们从顶级列表中删除。

要过滤内部列表，您应该有一个对外部对象进行操作的 .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 创建新的过滤版本。

对于.map() 方法，您需要有一个 lambda 来创建一个新的 OuterObject，这样：

• output.num == input.num
• output.innerObjectList == input.innerObjectList.stream().filter(s -> s.getNum() == 10)

这有意义吗？

Answer 3

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

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 4

outerObjectList.stream()
            .filter(outer -> outer.num == 10)
            .map(outerObject -> {
                outerObject.innerObjectList= outerObject.innerObjectList.stream().filter(innerObject -> innerObject.num == 10).collect(Collectors.toList());
                return outerObject;
            })
            .collect(Collectors.toList());