无法克隆/分叉流。您可以组合一系列运算符，并仅应用一次。因此，其中一种方法是利用元组存储中间结果（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

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

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岁的人，我们就知道问题是没有候选人有宠物。
我们可以尝试避免第二次迭代，但这会使代码更加复杂，而只有例外情况才会受益，代价是非错误情况。

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

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;
    })
    .findAtLeastOne() // <-- this method doesn't exist
    .orElseThrow() // <-- exception because no person was older than 18
    .filter(e -> e.hasPet())
    .findFirst()
    .orElseThrow(() -> !ageMatchedAtLeastOnce.get() ? new AgeException() : new NoPetException());

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