Question

我必须通过一个映射过滤一个对象集合，该映射包含对象字段名称和字段值的键值对。我正在尝试通过stream（）。filter（）应用所有过滤器。

对象实际上是JSON，因此Map保留了其变量的名称以及它们必须包含的值才能被接受，但是出于简单性的原因，并且因为它与问题无关，所以我编写了一个简单的Testclass用于模拟行为：

public class TestObject {

  private int property1;
  private int property2;
  private int property3;

  public TestObject(int property1, int property2, int property3) {
      this.property1 = property1;
      this.property2 = property2;
      this.property3 = property3;
  }

  public int getProperty(int key) {
      switch(key) {
          case 1: return property1;
          case 2: return property2;
          default: return property3;
      }
  }
}

到目前为止，我已经尝试过：

public static void main(String[] args) {
    List<TestObject> list = new ArrayList<>();
    Map<Integer, Integer> filterMap = new HashMap<>();
    list.add(new TestObject(1, 2, 3));
    list.add(new TestObject(1, 2, 4));
    list.add(new TestObject(1, 4, 3));
    filterMap.put(3, 3); //Filter property3 == 3
    filterMap.put(2, 2); //Filter property2 == 2

    //Does not apply the result
    filterMap.forEach((key, value) -> list.stream()
            .filter(testObject -> testObject.getProperty(key) == value)
            .collect(Collectors.toList())
    );
    /* Gives error: boolean can not be converted to void
    list = list.stream()
            .filter(testObject -> filterMap.forEach((key, value) -> testObject.getProperty(key) == value))
            .collect(Collectors.toList()
            );
    */
    //Printing result

    list.forEach(obj -> System.out.println(obj.getProperty(1) + " " + obj.getProperty(2) + " " + obj.getProperty(3)));
}

我尝试将Map的forEach放在首位，并将Collection的流放在首位，但是两种解决方案均无法按预期工作。此示例的期望输出将仅是打印具有值property1 = 1，property2 = 2和property3 = 3的对象。

我如何正确地应用所有过滤器，就像您在代码中使用固定数量的过滤器一个接一个地放置它们一样？

使用已知数量的过滤器：

list.stream().filter(...).filter(...)

编辑：

Sweeper在回答中很好地总结了我的问题，这里只是为了澄清（可能是将来的读者）：我想保留所有满足所有过滤条件的对象。

Answer 1

我想您想保留满足地图所有 all 条件的所有TestObjects吗？

这将完成工作：

List<TestObject> newList = list.stream()
        .filter(x ->
                filterMap.entrySet().stream()
                        .allMatch(y ->
                                x.getProperty(y.getKey()) == y.getValue()
                        )
        )
        .collect(Collectors.toList());

翻译成“英语”

  通过保留以下所有元素filter，来
list列表x：


y中的所有键值对filterMap必须满足：

x.getProperty(y.getKey()) == y.getValue()

（我认为我在使人类可读性方面做得不好...）如果您想要一个更具可读性的解决方案，我建议Jeroen Steenbeeke给出答案。

Answer 2

要将可变数量的过滤器步骤应用于流（仅在运行时才知道），可以使用循环添加过滤器步骤。

Stream<TestObject> stream = list.stream();
for (Predicate<TestObject> predicate: allPredicates) {
  stream = stream.filter(predicate);
}
list = stream.collect(Collectors.toList());

Answer 3

更通用的方法是创建一个使用Predicate或Predicate.and(...)串联在一起的多重过滤器（Predicate.or(...)）。这适用于使用Predicate的任何事物-首先是Stream和Optional。
由于结果本身就是Predicate，因此可以继续使用Predicate.and(...)或Predicate.or(...)，或者再次使用MultiPredicate来构建更复杂的谓词。

class MultiPredicate {

    public static <T> Predicate<T> matchingAll(Collection<Predicate<T>> predicates) {
        Predicate<T> multiPredicate = to -> true;
        for (Predicate<T> predicate : predicates) {
            multiPredicate = multiPredicate.and(predicate);
        }

        return multiPredicate;    
    }

    @SafeVarargs
    public static <T> Predicate<T> matchingAll(Predicate<T> first, Predicate<T>... other) {
        if (other == null || other.length == 0) {
            return first;
        }

        Predicate<T> multiPredicate = first;
        for (Predicate<T> predicate : other) {
            multiPredicate = multiPredicate.and(predicate);
        }

        return multiPredicate;
    }

    public static <T> Predicate<T> matchingAny(Collection<Predicate<T>> predicates) {
        Predicate<T> multiPredicate = to -> false;
        for (Predicate<T> predicate : predicates) {
            multiPredicate = multiPredicate.or(predicate);
        }

        return multiPredicate;    
    }

    @SafeVarargs
    public static <T> Predicate<T> matchingAny(Predicate<T> first, Predicate<T>... other) {
        if (other == null || other.length == 0) {
            return first;
        }

        Predicate<T> multiPredicate = first;
        for (Predicate<T> predicate : other) {
            multiPredicate = multiPredicate.or(predicate);
        }

        return multiPredicate;
    }

}

适用于该问题：

public static void main(String... args) {
    List<TestObject> list = new ArrayList<>();
    Map<Integer, Integer> filterMap = new HashMap<>();
    list.add(new TestObject(1, 2, 3));
    list.add(new TestObject(1, 2, 4));
    list.add(new TestObject(1, 4, 3));
    filterMap.put(3, 3); // Filter property3 == 3
    filterMap.put(2, 2); // Filter property2 == 2

    List<Predicate<TestObject>> filters = filterMap.entrySet().stream()
            .map(filterMapEntry -> mapToFilter(filterMapEntry))
            .collect(Collectors.toList());

    Predicate<TestObject> multiFilter = MultiPredicate.matchingAll(filters);
    List<TestObject> filtered = list.stream()
            .filter(multiFilter)
            .collect(Collectors.toList());
    for (TestObject to : filtered) {
        System.out.println("(" + to.getProperty(1) + "|" + to.getProperty(2) + "|" + to.getProperty(3) + ")");
    }

}

private static Predicate<TestObject> mapToFilter(Entry<Integer,Integer> filterMapEntry) {
    return to -> to.getProperty(filterMapEntry.getKey()) ==  filterMapEntry.getValue();
}

在这种情况下，所有过滤器都必须匹配。结果是：

(1|2|3)

如果我们使用MultiPredicate.matchingAny(...)，则结果为：

(1|2|3)  
(1|2|4)  
(1|4|3)

Answer 4

它与过滤器无关。实际上，过滤器永远不会按照您的代码运行。看看

//Does not apply the result
filterMap.forEach((key, value) -> list.stream()
        .filter(testObject -> testObject.getProperty(key) == value)
        .collect(Collectors.toList())
);

列表已被过滤，但此处未更改。尚未删除任何元素，也未更改任何对象地址。尝试removeIf

// Does not apply the result
filterMap.forEach((key, value) -> list.removeIf(testObject -> testObject.getProperty(key) != value));

输出是

1 2 3

如何在Java Stream上应用多个过滤器？

4 个答案: