next) {
- requireNonNull(next);
- requireNonNull(hasNext);
- return StreamSupport.stream(IterateSpliterator.create(seed, hasNext, next), false);
- }
-
- /**
- * 保留 与指定断言 匹配时的元素, 在第一次不匹配时终止, 抛弃当前(第一个不匹配元素)及后续所有元素
- * 与 jdk9 中的 takeWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作
- * 本环节中是顺序执行的, 但是后续操作可以支持并行流
- * 但是不建议在并行流中使用, 除非你确定 takeWhile 之后的操作能在并行流中受益很多
- *
- * @param source 源流
- * @param 元素类型
- * @param predicate 断言
- * @return 与指定断言匹配的元素组成的流
- */
- public static Stream takeWhile(Stream source, Predicate super T> predicate) {
- requireNonNull(source);
- requireNonNull(predicate);
- return createStatefulNewStream(source, TakeWhileSpliterator.create(source.spliterator(), predicate));
- }
-
- /**
- * 删除 与指定断言 匹配的元素, 在第一次不匹配时终止, 返回当前(第一个不匹配元素)及剩余元素组成的新流
- * 与 jdk9 中的 dropWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作
- * 本环节中是顺序执行的, 但是后续操作可以支持并行流
- * 但是不建议在并行流中使用, 除非你确定 dropWhile 之后的操作能在并行流中受益很多
- *
- * @param source 源流
- * @param 元素类型
- * @param predicate 断言
- * @return 剩余元素组成的流
- */
- public static Stream dropWhile(Stream source, Predicate super T> predicate) {
- requireNonNull(source);
- requireNonNull(predicate);
- return createStatefulNewStream(source, DropWhileSpliterator.create(source.spliterator(), predicate));
- }
-
- // region 私有方法
- /* ================================================== 私有方法 =================================================== */
-
- /**
- * 根据 源流 和 新的Spliterator 生成新的流
- * 这是一个 顺序的、有状态的流
- * 在新流的第一个节点是顺序执行的, 但是后续操作可以支持并行流
- *
- * @param source 源流
- * @param newSpliterator 新流的Spliterator
- * @param 旧流的元素类型
- * @param 新流的元素类型
- * @return 新流
- */
- private static Stream createStatefulNewStream(Stream source, Spliterator newSpliterator) {
- // 创建新流
- Stream newStream = StreamSupport.stream(newSpliterator, source.isParallel());
- // 如果旧流是并行流, 新流主动调用一个有状态的操作, 虽然没有意义, 但是可以让后续的无状态节点正常并发
- if (source.isParallel()) {
- newStream = newStream.limit(Long.MAX_VALUE);
- }
- // 由于新流不与旧流的节点关联, 所以需要主动设置旧流的close方法, 哪怕几乎不可能有人在旧流上设置onClose操作
- return newStream.onClose(source::close);
- }
-
- /* ============================================================================================================== */
- // endregion
-
-}
diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/support/TakeWhileSpliterator.java b/hutool-core/src/main/java/cn/hutool/core/stream/support/TakeWhileSpliterator.java
deleted file mode 100644
index dc0ca8da6..000000000
--- a/hutool-core/src/main/java/cn/hutool/core/stream/support/TakeWhileSpliterator.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package cn.hutool.core.stream.support;
-
-import java.util.Comparator;
-import java.util.Spliterator;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-/**
- * takeWhile 的 Spliterator
- * 借鉴自StreamEx
- *
- * @author emptypoint
- * @since 6.0.0
- */
-class TakeWhileSpliterator implements Spliterator {
-
- static TakeWhileSpliterator create(Spliterator source, Predicate super T> predicate) {
- return new TakeWhileSpliterator<>(source, predicate);
- }
-
- private final Spliterator source;
- private final Predicate super T> predicate;
- private boolean isContinue = true;
-
- TakeWhileSpliterator(Spliterator source, Predicate super T> predicate) {
- this.source = source;
- this.predicate = predicate;
- }
-
- @Override
- public boolean tryAdvance(Consumer super T> action) {
- boolean hasNext = true;
- // 如果 还可以继续 并且 流中还有元素 则继续遍历
- while (isContinue && hasNext) {
- hasNext = source.tryAdvance(e -> {
- if (predicate.test(e)) {
- action.accept(e);
- } else {
- // 终止遍历剩下的元素
- isContinue = false;
- }
- });
- }
- // 该环节已经处理完成
- return false;
- }
-
- @Override
- public Spliterator trySplit() {
- return null;
- }
-
- @Override
- public long estimateSize() {
- return isContinue ? source.estimateSize() : 0;
- }
-
- @Override
- public int characteristics() {
- return source.characteristics() & ~(Spliterator.SIZED | Spliterator.SUBSIZED);
- }
-
- @Override
- public Comparator super T> getComparator() {
- return source.getComparator();
- }
-}
-