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

Question

我有一个Validator接口，它提供了一个isValid（Thing）方法，返回一个ValidationResult，其中包含一个布尔值和一条原因消息。

我想创建此接口的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)
}

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

这被标记为你能把一个流分成两个流吗？和分区By答案排序是，但我认为这个问题是问，讨论回答，一个不同的问题。




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);
}

考虑对列表进行排序，这样成功几率更高的验证器就在开始时…