splice(final int start, final int deleteCount, final T... items) {
- return of(ListUtil.splice(toList(), start, deleteCount, items))
- .parallel(isParallel())
- .onClose(stream::close);
- }
-
/**
* 按指定长度切分为双层流
*
@@ -1055,85 +610,6 @@ public class EasyStream extends StreamWrapper> implements St
return split(batchSize).map(EasyStream::toList);
}
- /**
- * 保留 与指定断言 匹配时的元素, 在第一次不匹配时终止, 抛弃当前(第一个不匹配元素)及后续所有元素
- * 与 jdk9 中的 takeWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作
- * 本环节中是顺序执行的, 但是后续操作可以支持并行流: {@code
- * FastStream.iterate(1, i -> i + 1)
- * .parallel()
- * // 顺序执行
- * .takeWhile(e -> e < 50)
- * // 并发
- * .map(e -> e + 1)
- * // 并发
- * .map(String::valueOf)
- * .toList();
- * }
- * 但是不建议在并行流中使用, 除非你确定 takeWhile 之后的操作能在并行流中受益很多
- *
- * @param predicate 断言
- * @return 与指定断言匹配的元素组成的流
- */
- public EasyStream takeWhile(final Predicate predicate) {
- Objects.requireNonNull(predicate);
- return of(StreamUtil.takeWhile(stream, predicate));
- }
-
-
- /**
- * 删除 与指定断言 匹配的元素, 在第一次不匹配时终止, 返回当前(第一个不匹配元素)及剩余元素组成的新流
- * 与 jdk9 中的 dropWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作
- * 本环节中是顺序执行的, 但是后续操作可以支持并行流: {@code
- * FastStream.iterate(1, i <= 100, i -> i + 1)
- * .parallel()
- * // 顺序执行
- * .dropWhile(e -> e < 50)
- * // 并发
- * .map(e -> e + 1)
- * // 并发
- * .map(String::valueOf)
- * .toList();
- * }
- * 但是不建议在并行流中使用, 除非你确定 dropWhile 之后的操作能在并行流中受益很多
- *
- * @param predicate 断言
- * @return 剩余元素组成的流
- */
- public EasyStream dropWhile(final Predicate predicate) {
- Objects.requireNonNull(predicate);
- return of(StreamUtil.dropWhile(stream, predicate));
- }
-
- /**
- * 流是否为空
- *
- * @return 流是否为空
- */
- public boolean isEmpty() {
- return !findAny().isPresent();
- }
-
- /**
- * 流是否不为空
- *
- * @return 流是否不为空
- */
- public boolean isNotEmpty() {
- return !isEmpty();
- }
-
- /**
- * 将当前流转为另一对象。用于提供针对流本身而非流中元素的操作
- *
- * @param 转换类型
- * @param transform 转换
- * @return 转换后的流
- */
- public Optional transform(final Function, R> transform) {
- Assert.notNull(transform, "transform must not null");
- return Optional.ofNullable(transform.apply(this));
- }
-
public interface FastStreamBuilder extends Consumer, cn.hutool.core.builder.Builder> {
/**
diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/EntryStream.java b/hutool-core/src/main/java/cn/hutool/core/stream/EntryStream.java
index 81b7a6ecd..c9eadd81c 100644
--- a/hutool-core/src/main/java/cn/hutool/core/stream/EntryStream.java
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/EntryStream.java
@@ -22,7 +22,7 @@ import java.util.stream.StreamSupport;
* @param 值类型
* @author huangchengxing
*/
-public class EntryStream extends StreamWrapper, EntryStream> {
+public class EntryStream extends AbstractEnhancedStreamWrapper, EntryStream> {
/**
* 默认的空键值对
@@ -157,7 +157,7 @@ public class EntryStream extends StreamWrapper, EntryStrea
*/
public EntryStream distinctByKey() {
Set accessed = new ConcurrentHashSet<>(16);
- return convertToStreamImpl(stream.filter(e -> {
+ return wrapping(stream.filter(e -> {
K key = e.getKey();
if (accessed.contains(key)) {
return false;
@@ -174,7 +174,7 @@ public class EntryStream extends StreamWrapper, EntryStrea
*/
public EntryStream distinctByValue() {
Set accessed = new ConcurrentHashSet<>(16);
- return convertToStreamImpl(stream.filter(e -> {
+ return wrapping(stream.filter(e -> {
V val = e.getValue();
if (accessed.contains(val)) {
return false;
@@ -299,7 +299,7 @@ public class EntryStream extends StreamWrapper, EntryStrea
* @return {@link EntryStream}实例
*/
public EntryStream append(K key, V value) {
- return convertToStreamImpl(Stream.concat(stream, Stream.of(ofEntry(key, value))));
+ return wrapping(Stream.concat(stream, Stream.of(ofEntry(key, value))));
}
/**
@@ -310,7 +310,7 @@ public class EntryStream extends StreamWrapper, EntryStrea
* @return {@link EntryStream}实例
*/
public EntryStream prepend(K key, V value) {
- return convertToStreamImpl(Stream.concat(Stream.of(ofEntry(key, value)), stream));
+ return wrapping(Stream.concat(Stream.of(ofEntry(key, value)), stream));
}
/**
@@ -325,7 +325,7 @@ public class EntryStream extends StreamWrapper, EntryStrea
}
final Stream> contacted = StreamSupport.stream(entries.spliterator(), isParallel())
.map(EntryStream::ofEntry);
- return convertToStreamImpl(Stream.concat(stream, contacted));
+ return wrapping(Stream.concat(stream, contacted));
}
/**
@@ -340,7 +340,7 @@ public class EntryStream extends StreamWrapper, EntryStrea
}
final Stream> contacted = StreamSupport.stream(entries.spliterator(), isParallel())
.map(EntryStream::ofEntry);
- return convertToStreamImpl(Stream.concat(contacted, stream));
+ return wrapping(Stream.concat(contacted, stream));
}
/**
@@ -744,7 +744,7 @@ public class EntryStream extends StreamWrapper, EntryStrea
* @return 实现类
*/
@Override
- public EntryStream convertToStreamImpl(Stream> stream) {
+ public EntryStream wrapping(Stream> stream) {
return new EntryStream<>(stream);
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/SimpleStreamWrapper.java b/hutool-core/src/main/java/cn/hutool/core/stream/SimpleStreamWrapper.java
new file mode 100644
index 000000000..636e54f1f
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/SimpleStreamWrapper.java
@@ -0,0 +1,55 @@
+package cn.hutool.core.stream;
+
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+/**
+ * {@link AbstractEnhancedStreamWrapper}的基本实现
+ *
+ * @author huangchengxing
+ */
+public class SimpleStreamWrapper extends AbstractEnhancedStreamWrapper> {
+
+ /**
+ * 创建一个流包装器
+ *
+ * @param stream 包装的流对象
+ * @throws NullPointerException 当{@code stream}为{@code null}时抛出
+ */
+ SimpleStreamWrapper(Stream stream) {
+ super(stream);
+ }
+
+ /**
+ * 将一个流包装为{@link SimpleStreamWrapper}
+ *
+ * @param source 被包装的流
+ * @return 包装后的流
+ */
+ @Override
+ public SimpleStreamWrapper wrapping(Stream source) {
+ return new SimpleStreamWrapper<>(source);
+ }
+
+ /**
+ * 将当前流中元素映射为另一类型
+ *
+ * @param mapper 映射方法
+ * @return 映射后的流
+ */
+ @Override
+ public SimpleStreamWrapper map(Function mapper) {
+ return new SimpleStreamWrapper<>(stream().map(mapper));
+ }
+
+ /**
+ * 将当前流中元素展开为流，然后返回由这些新流中元素组成的流
+ *
+ * @param mapper 映射方法
+ * @return 映射后的流
+ */
+ @Override
+ public SimpleStreamWrapper flatMap(Function> mapper) {
+ return new SimpleStreamWrapper<>(stream().flatMap(mapper));
+ }
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/StreamWrapper.java b/hutool-core/src/main/java/cn/hutool/core/stream/StreamWrapper.java
index 60da8e88d..8c6519f66 100644
--- a/hutool-core/src/main/java/cn/hutool/core/stream/StreamWrapper.java
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/StreamWrapper.java
@@ -1,32 +1,57 @@
package cn.hutool.core.stream;
-import java.util.*;
+import cn.hutool.core.util.ObjUtil;
+
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.Optional;
+import java.util.Spliterator;
import java.util.function.*;
import java.util.stream.*;
/**
- * {@link Stream}的包装类，用于基于一个已有的流实例进行扩展
+ * 表示一个用于增强原始{@link Stream}对象的包装器，当调用{@link Stream}中的方法时，
+ * 将会代理到被包装的原始流对象，并返回指定的包装器实例。
*
+ * @param 流中的元素类型
+ * @param 链式调用获得的实现类类型
* @author huangchengxing
- * @see EasyStream
+ * @see TerminableStreamWrapper
+ * @see TransformableStreamWrapper
+ * @see AbstractEnhancedStreamWrapper
*/
-abstract class StreamWrapper> implements Stream, Iterable {
+public interface StreamWrapper> extends Stream, Iterable {
/**
- * 原始的流实例
+ * 代表不存在的下标, 一般用于并行流的下标, 或者未找到元素时的下标
*/
- protected final Stream stream;
+ int NOT_FOUND_INDEX = -1;
/**
- * 创建一个流包装器
+ * 将一个流包装为简单增强流，若{@code stream}为{@code null}则默认返回一个空串行流
*
- * @param stream 包装的流对象
+ * @param stream 被包装的流
+ * @return {@link SimpleStreamWrapper}实例
*/
- protected StreamWrapper(Stream stream) {
- Objects.requireNonNull(stream, "stream must not null");
- this.stream = stream;
+ static SimpleStreamWrapper create(Stream stream) {
+ return new SimpleStreamWrapper<>(ObjUtil.defaultIfNull(stream, Stream.empty()));
}
+ /**
+ * 获取被包装的原始流
+ *
+ * @return 被包装的原始流
+ */
+ Stream stream();
+
+ /**
+ * 将一个原始流包装为指定类型的增强流
+ *
+ * @param source 被包装的流
+ * @return I
+ */
+ I wrapping(Stream source);
+
/**
* 过滤元素，返回与指定断言匹配的元素组成的流
* 这是一个无状态中间操作
@@ -35,8 +60,8 @@ abstract class StreamWrapper> implements Stream, Itera
* @return 返回叠加过滤操作后的流
*/
@Override
- public I filter(Predicate predicate) {
- return convertToStreamImpl(stream.filter(predicate));
+ default I filter(Predicate predicate) {
+ return wrapping(stream().filter(predicate));
}
/**
@@ -47,8 +72,8 @@ abstract class StreamWrapper> implements Stream, Itera
* @return 叠加操作后元素类型全为int的流
*/
@Override
- public IntStream mapToInt(ToIntFunction mapper) {
- return stream.mapToInt(mapper);
+ default IntStream mapToInt(ToIntFunction mapper) {
+ return stream().mapToInt(mapper);
}
/**
@@ -59,8 +84,8 @@ abstract class StreamWrapper> implements Stream, Itera
* @return 叠加操作后元素类型全为long的流
*/
@Override
- public LongStream mapToLong(ToLongFunction mapper) {
- return stream.mapToLong(mapper);
+ default LongStream mapToLong(ToLongFunction mapper) {
+ return stream().mapToLong(mapper);
}
/**
@@ -71,8 +96,8 @@ abstract class StreamWrapper> implements Stream, Itera
* @return 叠加操作后元素类型全为double的流
*/
@Override
- public DoubleStream mapToDouble(ToDoubleFunction mapper) {
- return stream.mapToDouble(mapper);
+ default DoubleStream mapToDouble(ToDoubleFunction mapper) {
+ return stream().mapToDouble(mapper);
}
/**
@@ -83,8 +108,8 @@ abstract class StreamWrapper> implements Stream, Itera
* @return 返回叠加拆分操作后的IntStream
*/
@Override
- public IntStream flatMapToInt(Function mapper) {
- return stream.flatMapToInt(mapper);
+ default IntStream flatMapToInt(Function mapper) {
+ return stream().flatMapToInt(mapper);
}
/**
@@ -95,8 +120,8 @@ abstract class StreamWrapper> implements Stream, Itera
* @return 返回叠加拆分操作后的LongStream
*/
@Override
- public LongStream flatMapToLong(Function mapper) {
- return stream.flatMapToLong(mapper);
+ default LongStream flatMapToLong(Function mapper) {
+ return stream().flatMapToLong(mapper);
}
/**
@@ -107,8 +132,8 @@ abstract class StreamWrapper> implements Stream, Itera
* @return 返回叠加拆分操作后的DoubleStream
*/
@Override
- public DoubleStream flatMapToDouble(Function mapper) {
- return stream.flatMapToDouble(mapper);
+ default DoubleStream flatMapToDouble(Function mapper) {
+ return stream().flatMapToDouble(mapper);
}
/**
@@ -118,8 +143,8 @@ abstract class StreamWrapper> implements Stream, Itera
* @return 一个具有去重特征的流
*/
@Override
- public I distinct() {
- return convertToStreamImpl(stream.distinct());
+ default I distinct() {
+ return wrapping(stream().distinct());
}
/**
@@ -131,8 +156,8 @@ abstract class StreamWrapper> implements Stream, Itera
* @return 一个元素按自然顺序排序的流
*/
@Override
- public I sorted() {
- return convertToStreamImpl(stream.sorted());
+ default I sorted() {
+ return wrapping(stream().sorted());
}
/**
@@ -145,8 +170,8 @@ abstract class StreamWrapper> implements Stream, Itera
* @return 一个元素按指定的Comparator排序的流
*/
@Override
- public I sorted(Comparator comparator) {
- return convertToStreamImpl(stream.sorted(comparator));
+ default I sorted(Comparator comparator) {
+ return wrapping(stream().sorted(comparator));
}
/**
@@ -167,8 +192,8 @@ abstract class StreamWrapper> implements Stream, Itera
* }
*/
@Override
- public I peek(Consumer action) {
- return convertToStreamImpl(stream.peek(action));
+ default I peek(Consumer action) {
+ return wrapping(stream().peek(action));
}
/**
@@ -179,8 +204,8 @@ abstract class StreamWrapper> implements Stream, Itera
* @return 截取后的流
*/
@Override
- public I limit(long maxSize) {
- return convertToStreamImpl(stream.limit(maxSize));
+ default I limit(long maxSize) {
+ return wrapping(stream().limit(maxSize));
}
/**
@@ -191,8 +216,8 @@ abstract class StreamWrapper