这样的操作在Java 8 Stream中应该是可能的，但它不一定能高效地完成——例如，您不一定能将这样的操作并行化，因为您必须按顺序查看元素。

API并没有提供简单的方法，但最简单的方法可能是获取Stream. Iterator()，将迭代器包装为“take-while”实现，然后返回到Spliterator，然后是Stream。或者——可能——包装Spliterator，尽管在这个实现中它不能再被拆分了。

下面是一个未测试的takeWhile在Spliterator上的实现:

static <T> Spliterator<T> takeWhile(
    Spliterator<T> splitr, Predicate<? super T> predicate) {
  return new Spliterators.AbstractSpliterator<T>(splitr.estimateSize(), 0) {
    boolean stillGoing = true;
    @Override public boolean tryAdvance(Consumer<? super T> consumer) {
      if (stillGoing) {
        boolean hadNext = splitr.tryAdvance(elem -> {
          if (predicate.test(elem)) {
            consumer.accept(elem);
          } else {
            stillGoing = false;
          }
        });
        return hadNext && stillGoing;
      }
      return false;
    }
  };
}

static <T> Stream<T> takeWhile(Stream<T> stream, Predicate<? super T> predicate) {
   return StreamSupport.stream(takeWhile(stream.spliterator(), predicate), false);
}

allMatch()是一个短路函数，因此可以使用它来停止处理。主要的缺点是您必须进行两次测试:一次是查看是否应该处理它，另一次是查看是否继续进行。

IntStream
    .iterate(1, n -> n + 1)
    .peek(n->{if (n<10) System.out.println(n);})
    .allMatch(n->n < 10);

可能有点离题了，但这是List<T>而不是Stream<T>。

首先你需要有一个take util方法。该方法接受前n个元素:

static <T> List<T> take(List<T> l, int n) {
    if (n <= 0) {
        return newArrayList();
    } else {
        int takeTo = Math.min(Math.max(n, 0), l.size());
        return l.subList(0, takeTo);
    }
}

它就像scala。list。take一样

    assertEquals(newArrayList(1, 2, 3), take(newArrayList(1, 2, 3, 4, 5), 3));
    assertEquals(newArrayList(1, 2, 3), take(newArrayList(1, 2, 3), 5));

    assertEquals(newArrayList(), take(newArrayList(1, 2, 3), -1));
    assertEquals(newArrayList(), take(newArrayList(1, 2, 3), 0));

现在，编写一个基于take的takeWhile方法就相当简单了

static <T> List<T> takeWhile(List<T> l, Predicate<T> p) {
    return l.stream().
            filter(p.negate()).findFirst(). // find first element when p is false
            map(l::indexOf).        // find the index of that element
            map(i -> take(l, i)).   // take up to the index
            orElse(l);  // return full list if p is true for all elements
}

它是这样工作的:

    assertEquals(newArrayList(1, 2, 3), takeWhile(newArrayList(1, 2, 3, 4, 3, 2, 1), i -> i < 4));

这个实现部分迭代列表几次，但它不会增加O(n^2)个操作。希望你能接受。

如果你有不同的问题，可能需要不同的解决方案，但对于你当前的问题，我只想说:

IntStream
    .iterate(1, n -> n + 1)
    .limit(10)
    .forEach(System.out::println);

如果您知道将要执行的重复的确切数量，您就可以执行

IntStream
          .iterate(1, n -> n + 1)
          .limit(10)
          .forEach(System.out::println);

去图书馆拿算盘——普通的算盘。它提供了你想要的API和更多:

IntStream.iterate(1, n -> n + 1).takeWhile(n -> n < 10).forEach(System.out::println);

声明:我是AbacusUtil的开发者。