根据哪个过滤器从流中过滤了最后一个元素，反应不同

Question

我尝试根据过滤最后一个元素的过滤器引发异常：

// Find the first person who is older than 18 and has a pet
Person firstOlderThan18AndWithPet =  this.people.entrySet().stream()
    .map(e -> e.getValue())
    .filter(e -> e.getAge() >= 18)
    .findAtLeastOne() // <-- this method doesn't exist
    .orElseThrow(AgeException::new) // <-- exception because no person was older than 18
    .filter(e -> e.hasPet())
    .findFirst()
    .orElseThrow(NoPetException::new); // <-- exception because no person older than 18 has a pet

这样我就可以分辨出为什么在人流中没有发现任何人。是因为年龄还是因为没有人养宠物。

我只看到一个选项，并用两个流来实现它？

List<Person> peopleOlderThan18 = this.people.entrySet().stream()
    .map(e -> e.getValue())
    .filter(e -> e.getAge() >= 18)
    .collect(Collectors.toList());

if (0 == peopleOlderThan18.size()) {
    throw new AgeException();
}

Person firstOlderThan18AndWithPet = peopleOlderThan18.stream()
    .filter(e -> e.hasPet())
    .findFirst()
    .orElseThrow(NoPetException::new); // <-- exception because no person older than 18 has a pet

或者我能做些什么来把所有的事情都集中在一个流里？

Answer 1

我现在想出了一个解决方案，在这个解决方案中，我可以抛出正确的异常，而不会在中间留下流。我使用的解决方案如下所示：

AtomicBoolean ageMatchedAtLeastOnce = new AtomicBoolean(false);

// Find the first person who is older than 18 and has a pet
Person firstOlderThan18AndWithPet =  this.people.entrySet().stream()
    .map(e -> e.getValue())
    .filter(e -> {
        var ageMatch = e.getAge() >= 18
     
        if (ageMatch) {
            ageMatchedAtLeastOnce.set(true);
        }

        return ageMatch;
    })
    .filter(e -> e.hasPet())
    .findFirst()
    .orElseThrow(() -> !ageMatchedAtLeastOnce.get() ? new AgeException() : new NoPetException());

我不知道这是不是一个好的解决方案。很高兴在评论中听到你的意见。

Answer 2

无法克隆/分叉流。您可以组合一系列运算符，并只应用一次。因此，其中一种方法是利用元组存储中间结果（Java中没有元组文本）。为了在不损失代码表达能力的情况下保留流的优点，您可以提取公共部分并重新初始化流以应用另一组运算符。

    Predicate<Person> olderThan18 = person -> person.age >= 18;

    Person firstOlderThan18 = people.stream()
      .filter(olderThan18)
      .findFirst()
      .orElseThrow(Exception::new);

    Person firstOlderThan18AndWithPet = people.stream()
      .filter(olderThan18)
      .filter(person -> person.hasPet)
      .findFirst()
      .orElseThrow(AssertionError::new);

https://replit.com/join/rxbbvwoudq-redneckz

Answer 3

您必须决定要针对哪种情况进行优化。

通常，我们针对无错误情况进行优化。因此，我们可以乐观地尝试在单个迭代中找到匹配元素，而无需额外存储：

Person firstOlderThan18AndWithPet =  this.people.values().stream()
    .filter(e -> e.getAge() >= 18 && e.hasPet())
    .findFirst()
    .orElseThrow(() ->
        this.people.values().stream().nonMatch(e -> e.getAge() >= 18)?
        new AgeException():
        new NoPetException()
    );

只有在未找到匹配项且第二次迭代短路时，才会执行第二次迭代。在这个错误的案例中，一旦我们遇到18岁以上的人，我们就知道问题是没有候选人有宠物。

我们可以尝试避免第二次迭代，但这会使代码更加复杂，而只有例外情况才会受益，代价是非错误情况。