返回 Java 流中的第一个结果匹配谓词或所有不匹配的结果

Question

我有一个Validator 接口，它提供了一个isValid(Thing) 方法，返回一个ValidationResult，其中包含一个boolean 和一个原因消息。

我想创建此接口的ValidatorAggregator 实现，该实现跨多个Validators 执行OR（如果任何Validator 返回正结果，则结果为正）。如果任何验证器成功，我想短路并返回其结果。如果没有验证器成功，我想返回所有失败消息。

我可以使用流和findFirst().orElse(...) 简洁地做到这一点，但使用这种模式，如果findFirst 返回空，我会丢失所有中间结果：

public ValidationResult isValid(final Thing thing) {
    return validators.stream()
      .map(v -> validator.isValid(thing))
      .filter(ValidationResult::isValid)
      .findFirst()
      .orElseGet(() -> new ValidationResult(false, "All validators failed'));
}

有什么方法可以使用流捕获失败的结果，或者比下面的更简洁？

public ValidationResult isValid(final Thing thing) {
    final Set<ValidationResult> failedResults = new HashSet<>();
    for (Validator validator : validators) {
        final ValidationResult result = validator.isValid(thing);
        if (result.isValid()) {
            return result;
        }
        failedResults.add(result);
    }
    return new ValidationResult(false, "No successful validator: " + failedResults); 
    // (assume failedResults stringifies nicely)
}

---

编辑：基于 cmets，我同意我正在尝试做的是过早优化（特别是因为这些验证器非常轻量级）。我可能会采用类似于 Holger 的计算所有验证并划分成成功/不成功结果的解决方案。

这被标记为 Can you split a stream into two streams? 的欺骗，而 partitioningBy 的答案是，但我认为这个问题是在问，而讨论的答案是另一个问题。 p>

Answer 1

没有完美的解决方案可以以相同的效率处理所有案件。即使您的循环变体满足了短路和仅处理一次验证器的标准，也存在创建和填充集合的缺点，如果只有一次验证成功，这可能会变得不必要。

选择取决于与操作相关的实际成本以及至少进行一次成功验证的可能性。如果以最佳性能处理常见情况，则可能会超过解决方案对处理不常见情况的惩罚。

所以

// you may use this if the likelihood of a success is high; assumes
// reasonable costs for the validation and consists (repeatable) results
public ValidationResult isValid(final Thing thing) {
    return validators.stream()
      .map(v -> v.isValid(thing))
      .filter(ValidationResult::isValid)
      .findFirst()
      .orElseGet(() -> new ValidationResult(false, "All validators failed"
        + validators.stream().map(v -> v.isValid(thing)).collect(Collectors.toSet())));
}

// you may use this if the likelihood of a success is
// very low and/or you intent to utilize parallel processing
public ValidationResult isValid(final Thing thing) {
    Map<Boolean,Set<ValidationResult>> results = validators.stream()
        .map(v -> v.isValid(thing))
        .collect(Collectors.partitioningBy(ValidationResult::isValid, Collectors.toSet()));
    return results.get(true).stream().findAny()
        .orElseGet(() -> new ValidationResult(false,
                             "No successful validator: "+results.get(false)));
}

// if chances of successful validation are mixed or unpredictable
// or validation is so expensive that everything else doesn't matter
// stay with the loop
public ValidationResult isValid(final Thing thing) {
    final Set<ValidationResult> failedResults = new HashSet<>();
    for (Validator validator : validators) {
        final ValidationResult result = validator.isValid(thing);
        if (result.isValid()) {
            return result;
        }
        failedResults.add(result);
    }
    return new ValidationResult(false, "No successful validator: " + failedResults);
}

考虑对列表进行排序，使成功机会更高的验证者排在最前面……