Java流：查找多个过滤器谓词的第一个

Question

我收集了< code >

             | isNew | isSoldOut
--------------------------------
predicate 1: | false | false
predicate 2: | false | true
predicate 3: | true  | false
predicate 4: | true  | true

我想找到“每种类型中的一种”，尽管我想找到产品集合中每个谓词的第一个匹配项。

目前我的代码如下：

java prettyprint-override">List<Product> products = getProducts();
List<Predicate<Product>> predicates = getPredicates();

List<Product> result = predicates.stream()
  .flatMap(predicate -> products.stream().filter(predicate).findFirst().stream())
  .collect(Collectors.toList());

但这当然会多次迭代产品集合，这是不需要的，因为在我的例子中，我有100000个产品和64个谓词，并且需要很长时间。

在我的特例中，谓词是互斥的:如果一个谓词返回true，那么对于该特定产品，所有其他谓词都可以跳过。因为我使用了< code>findFirst,所以对于所有其他产品，可以跳过这个谓词。

我想知道是否可以迭代产品集合，并根据所有谓词检查每个产品一次。

Answer 1

如果我理解正确，你正在寻找这样的东西：

List<Product> results = products.stream()
                        .filter(prod -> predicates.stream()
                                        .anyMatch(pred -> pred.test(prod)))
                        .collect(Collectors.toList());

Answer 2

您当前的解决方案将对集合进行多次迭代，但是由于< code>findFirst是一个短路操作符，它将在找到匹配项后立即停止。你是否对它进行了基准测试，以确保它不够好？

另一种方法是使用有状态过滤器（见本文顶部答案）：

public static Predicate<Product> matchAndDiscard(final List<Predicate<Product>> predicates) {
  final Set<Predicate<Product>> remaining = new HashSet<>(predicates);
  return product -> {
    final var match = remaining.stream().filter(pred -> pred.test(product)).findFirst();
    match.ifPresent(remaining::remove);
    return match.isPresent();
  };
}

很像@Chaosfire的方法，但包含在过滤器函数中的状态。如果您相信所有谓词都会被至少一个产品匹配，您还可以通过将流限制为谓词的数量来节省一些时间，如下所示：

final var predicates = getPredicates()
final var result = getProducts().stream()
    .filter(matchAndDiscard(predicates))
    .limit(predicates.size())
    .toList()

在您当前的解决方案中，您将“水平”遍历产品：

       --> products
pred1: ffffffffffffft
pred2: fffft
pred3: ffffffffffffffft
pred4: ft
etc.

另一种方法是进行“垂直”遍历:

           products
pred1: | ffffffffffffft
pred2: | fffft
pred3: v ffff fffffffffft
pred4:   ft

因此，一个比另一个快得多并不明显，这取决于特定的配置。

Answer 3

反过来做怎么样？对产品进行流处理，并对它们应用谓词。

List<Predicate<Product>> predicates = getPredicates();
List<Product> products = getProducts();
List<Product> filtered = products.stream().filter(product -> {
    Iterator<Predicate<Product>> iterator = predicates.iterator();
    while (iterator.hasNext()) {
        Predicate<Product> currentPredicate = iterator.next();
        if (currentPredicate.test(product)) {
             iterator.remove();
             return true;
        }
    }
    return false;
}).collect(Collectors.toList());

缺点是您必须小心将哪个集合用于谓词，并不总是支持Iterator.remove。

编辑：看来我读得不够仔细。我认为使用循环时，每种方法各取一个效果最好。

List<Product> products = getProducts();
List<Predicate<Product>> predicates = getPredicates();
List<Product> matchingProducts = new ArrayList<>(predicates.size());
for (Product product : products) {
    if (predicates.isEmpty()) {
        break;
    }
    for (int predicateIndex = 0; predicateIndex < predicates.size(); predicateIndex++) {
        Predicate<Product> predicate = predicates.get(predicateIndex);
        if (predicate.test(product)) {
            matchingProducts.add(product);
            predicates.remove(predicateIndex);
            break;
        }
    }
}

实际上，设法通过一条流来实现它，并花了时间，你是对的，本杰明。

List<Predicate<Product>> predicates = getPredicates();
List<Product> products = getProducts();
List<Product> matches = products.stream()
        .takeWhile(product -> !predicates.isEmpty())
        .filter(product -> {
            Iterator<Predicate<Product>> iterator = predicates.iterator();
            while (iterator.hasNext()) {
                if (iterator.next().test(product)) {
                    iterator.remove();
                    return true;
                }
            }
            return false;
        })
        .collect(Collectors.toList());

只需确保takwhile在filter之前，否则会跳过最后一个匹配元素。