EasyStream (hutool-core 6.0.0-M6 API)

java.lang.Object
- org.dromara.hutool.core.stream.AbstractEnhancedWrappedStream<T,EasyStream<T>>
- - org.dromara.hutool.core.stream.EasyStream<T>

类型参数:

T - 对象类型

所有已实现的接口:

AutoCloseable, Iterable<T>, BaseStream<T,Stream<T>>, Stream<T>, TerminableWrappedStream<T,EasyStream<T>>, TransformableWrappedStream<T,EasyStream<T>>, WrappedStream<T,EasyStream<T>>
```
public class EasyStream<T>
extends AbstractEnhancedWrappedStream<T,EasyStream<T>>
```
单元素的扩展流实现。基于原生Stream进行了封装和增强。
作者经对比了vavr、eclipse-collection、unwrap-ex以及其他语言的api，结合日常使用习惯，进行封装和拓展 Stream为集合提供了一些易用api，它让开发人员能使用声明式编程的方式去编写代码。
中间操作和结束操作

针对流的操作分为分为中间操作和结束操作, 流只有在结束操作时才会真正触发执行以往的中间操作。
中间操作：
- 无状态中间操作: 表示不用等待所有元素的当前操作执行完就可以执行的操作，不依赖之前历史操作的流的状态；
- 有状态中间操作: 表示需要等待所有元素的当前操作执行完才能执行的操作,依赖之前历史操作的流的状态；
结束操作：
- 短路结束操作: 表示不用等待所有元素的当前操作执行完就可以执行的操作；
- 非短路结束操作: 表示需要等待所有元素的当前操作执行完才能执行的操作；
串行流与并行流

流分为串行流和并行流两类：
- 串行流：针对流的所有操作都会通过当前线程完成；
- 并行流：针对流的操作会通过拆分器Spliterator拆分为多个异步任务ForkJoinTask执行，这些异步任务默认使用ForkJoinPool线程池进行管理；
不同类型的流可以通过WrappedStream.sequential()或WrappedStream.parallel()互相转换。
作者:

VampireAchao, emptypoint, huangchengxing

从以下版本开始:

6.0.0

另请参阅:

Stream

嵌套类概要

嵌套类
限定符和类型类和说明

static interface EasyStream.Builder<T>
建造者

嵌套类
限定符和类型	类和说明
`static interface`	`EasyStream.Builder<T>` 建造者

字段概要
- 从类继承的字段 org.dromara.hutool.core.stream.AbstractEnhancedWrappedStream
  stream
- 从接口继承的字段 org.dromara.hutool.core.stream.WrappedStream
  NOT_FOUND_ELEMENT_INDEX

方法概要

所有方法静态方法实例方法具体方法
限定符和类型	方法和说明
`Opt<BigDecimal>`	`avg(Function<? super T,BigDecimal> mapper)` 计算 `BigDecimal` 类型的平均值并以四舍五入的方式保留2位精度
`Opt<BigDecimal>`	`avg(Function<? super T,BigDecimal> mapper, int scale)` `BigDecimal` 类型的平均值并以四舍五入的方式保留小数点后scale位
`Opt<BigDecimal>`	`avg(Function<? super T,BigDecimal> mapper, int scale, RoundingMode roundingMode)` 计算 `BigDecimal` 类型的平均值
`OptionalDouble`	`avg(ToDoubleFunction<? super T> mapper)` 计算double类型的平均值
`OptionalDouble`	`avg(ToIntFunction<? super T> mapper)` 计算int类型的平均值
`OptionalDouble`	`avg(ToLongFunction<? super T> mapper)` 计算double平均值
`static <T> EasyStream.Builder<T>`	`builder()` 返回`FastStream`的建造器
`static <T> EasyStream<T>`	`concat(Stream<? extends T> a, Stream<? extends T> b)` 创建一个惰性拼接流，其元素是第一个流的所有元素，然后是第二个流的所有元素。
`static <T> EasyStream<T>`	`empty()` 返回空的串行流
`static <T> EasyStream<T>`	`generate(Supplier<T> s)` 返回无限串行无序流其中每一个元素都由给定的`Supplier`生成适用场景在一些生成常量流、随机元素等
`static <T> EasyStream<T>`	`iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)` 返回无限有序流该流由初始值然后判断条件以及执行迭代函数进行迭代获取到元素例如 `FastStream.iterate(0, i -> i < 3, i -> ++i)` 就可以创建包含元素0,1,2的流，使用`WrappedStream.limit(long)`可以限制元素个数
`static <T> EasyStream<T>`	`iterate(T seed, UnaryOperator<T> f)` 返回无限有序流该流由初始值以及执行迭代函数进行迭代获取到元素例如 `FastStream.iterate(0, i -> i + 1)` 就可以创建从0开始，每次+1的无限流，使用`WrappedStream.limit(long)`可以限制元素个数
`<R> EasyStream<R>`	`map(Function<? super T,? extends R> mapper)` 返回与指定函数将元素作为参数执行的结果组成的流这是一个无状态中间操作
`static <T> EasyStream<T>`	`of(Iterable<T> iterable)` 通过实现了`Iterable`接口的对象创建串行流，若输入对象为`null`，则返回一个空的串行流
`static <T> EasyStream<T>`	`of(Iterable<T> iterable, boolean parallel)` 通过传入的`Iterable`创建流，若输入对象为`null`，则返回一个空的串行流
`static <T> EasyStream<T>`	`of(Stream<T> stream)` 通过传入的`Stream`创建流，若输入对象为`null`，则返回一个空的串行流
`static <T> EasyStream<T>`	`of(T... values)` 返回包含指定元素的串行流，若输入数组为`null`或空，则返回一个空的串行流
`static <T> EasyStream<T>`	`of(T t)` 返回包含单个元素的串行流
`static EasyStream<String>`	`split(CharSequence str, String regex)` 拆分字符串，转换为串行流
`<R extends Number> BigDecimal`	`sum(Function<? super T,R> mapper)` 计算 `Number` 类型的总和
`double`	`sum(ToDoubleFunction<? super T> mapper)` 计算double类型的总和
`int`	`sum(ToIntFunction<? super T> mapper)` 计算int类型的总和
`long`	`sum(ToLongFunction<? super T> mapper)` 计算long类型的总和
`EasyStream<T>`	`wrap(Stream<T> stream)` 根据一个原始的流，返回一个新包装类实例

从类继承的方法 org.dromara.hutool.core.stream.AbstractEnhancedWrappedStream
equals, exec, hashCode, toString, unwrap

从类继承的方法 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

从接口继承的方法 org.dromara.hutool.core.stream.TerminableWrappedStream
at, findFirst, findFirstIdx, findLast, findLast, findLastIdx, forEachIdx, forEachOrderedIdx, group, group, group, isEmpty, isNotEmpty, join, join, join, partition, partition, partition, toColl, toIdxMap, toIdxMap, toList, toMap, toMap, toMap, toMap, toSet, toUnmodifiableList, toUnmodifiableMap, toUnmodifiableMap, toUnmodifiableSet, toZip

从接口继承的方法 org.dromara.hutool.core.stream.TransformableWrappedStream
append, distinct, dropWhile, filter, filterIdx, flat, flat, flatMap, flatMapIdx, flatNonNull, flatTree, log, mapIdx, mapMulti, mapNonNull, nonNull, parallel, peekIdx, prepend, push, reverse, splice, split, splitList, takeWhile, toEntries, toEntries, unshift, zip

从接口继承的方法 org.dromara.hutool.core.stream.WrappedStream
allMatch, anyMatch, close, collect, collect, count, distinct, easyStream, filter, findAny, findFirst, flatMapToDouble, flatMapToInt, flatMapToLong, forEach, forEachOrdered, isParallel, iterator, limit, mapToDouble, mapToInt, mapToLong, max, min, noneMatch, onClose, parallel, peek, reduce, reduce, reduce, sequential, skip, sorted, sorted, spliterator, toArray, toArray, unordered

- 方法详细资料
  - builder
```
public static <T> EasyStream.Builder<T> builder()
```
    返回FastStream的建造器
    
    类型参数:
    
    T - 元素的类型
    
    返回:
    
    a unwrap builder
  - empty
```
public static <T> EasyStream<T> empty()
```
    返回空的串行流
    
    类型参数:
    
    T - 元素类型
    
    返回:
    
    一个空的串行流
  - of
```
public static <T> EasyStream<T> of(T t)
```
    返回包含单个元素的串行流
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    t - 单个元素
    
    返回:
    
    包含单个元素的串行流
  - of
```
@SafeVarargs
public static <T> EasyStream<T> of(T... values)
```
    返回包含指定元素的串行流，若输入数组为null或空，则返回一个空的串行流
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    values - 指定元素
    
    返回:
    
    包含指定元素的串行流从一个安全数组中创建流
  - of
```
public static <T> EasyStream<T> of(Iterable<T> iterable)
```
    通过实现了Iterable接口的对象创建串行流，若输入对象为null，则返回一个空的串行流
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    iterable - 实现了Iterable接口的对象
    
    返回:
    
    流
  - of
```
public static <T> EasyStream<T> of(Iterable<T> iterable,
                                   boolean parallel)
```
    通过传入的Iterable创建流，若输入对象为null，则返回一个空的串行流
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    iterable - Iterable
    
    parallel - 是否并行
    
    返回:
    
    流
  - of
```
public static <T> EasyStream<T> of(Stream<T> stream)
```
    通过传入的Stream创建流，若输入对象为null，则返回一个空的串行流
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    stream - Stream
    
    返回:
    
    流
  - iterate
```
public static <T> EasyStream<T> iterate(T seed,
                                        UnaryOperator<T> f)
```
    返回无限有序流该流由初始值以及执行迭代函数进行迭代获取到元素
    例如 FastStream.iterate(0, i -> i + 1) 就可以创建从0开始，每次+1的无限流，使用WrappedStream.limit(long)可以限制元素个数
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    seed - 初始值
    
    f - 用上一个元素作为参数执行并返回一个新的元素
    
    返回:
    
    无限有序流
  - iterate
```
public static <T> EasyStream<T> iterate(T seed,
                                        Predicate<? super T> hasNext,
                                        UnaryOperator<T> next)
```
    返回无限有序流该流由初始值然后判断条件以及执行迭代函数进行迭代获取到元素
    例如 FastStream.iterate(0, i -> i < 3, i -> ++i) 就可以创建包含元素0,1,2的流，使用WrappedStream.limit(long)可以限制元素个数
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    seed - 初始值
    
    hasNext - 条件值
    
    next - 用上一个元素作为参数执行并返回一个新的元素
    
    返回:
    
    无限有序流
  - generate
```
public static <T> EasyStream<T> generate(Supplier<T> s)
```
    返回无限串行无序流其中每一个元素都由给定的Supplier生成适用场景在一些生成常量流、随机元素等
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    s - 用来生成元素的 Supplier
    
    返回:
    
    无限串行无序流
  - concat
```
public static <T> EasyStream<T> concat(Stream<? extends T> a,
                                       Stream<? extends T> b)
```
    创建一个惰性拼接流，其元素是第一个流的所有元素，然后是第二个流的所有元素。如果两个输入流都是有序的，则结果流是有序的，如果任一输入流是并行的，则结果流是并行的。当结果流关闭时，两个输入流的关闭处理程序都会被调用。
    从重复串行流进行拼接时可能会导致深度调用链甚至抛出 StackOverflowException
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    a - 第一个流
    
    b - 第二个流
    
    返回:
    
    拼接两个流之后的流
  - split
```
public static EasyStream<String> split(CharSequence str,
                                       String regex)
```
    拆分字符串，转换为串行流
    
    参数:
    
    str - 字符串
    
    regex - 正则
    
    返回:
    
    拆分后元素组成的流
  - map
```
public <R> EasyStream<R> map(Function<? super T,? extends R> mapper)
```
    返回与指定函数将元素作为参数执行的结果组成的流这是一个无状态中间操作
    
    类型参数:
    
    R - 函数执行后返回的类型
    
    参数:
    
    mapper - 指定的函数
    
    返回:
    
    返回叠加操作后的流
  - wrap
```
public EasyStream<T> wrap(Stream<T> stream)
```
    根据一个原始的流，返回一个新包装类实例
    
    参数:
    
    stream - 流
    
    返回:
    
    实现类
  - sum
```
public int sum(ToIntFunction<? super T> mapper)
```
    计算int类型的总和
    
    参数:
    
    mapper - 将对象转换为int的 Function
    
    返回:
    
    int 总和
  - sum
```
public long sum(ToLongFunction<? super T> mapper)
```
    计算long类型的总和
    
    参数:
    
    mapper - 将对象转换为long的 Function
    
    返回:
    
    long 总和
  - sum
```
public double sum(ToDoubleFunction<? super T> mapper)
```
    计算double类型的总和
    
    参数:
    
    mapper - 将对象转换为double的 Function
    
    返回:
    
    double 总和
  - sum
```
public <R extends Number> BigDecimal sum(Function<? super T,R> mapper)
```
    计算 Number 类型的总和
    
    类型参数:
    
    R - 数字
    
    参数:
    
    mapper - 将对象转换为Number 的 Function
    
    返回:
    
    BigDecimal , 如果流为空, 返回 BigDecimal.ZERO
  - avg
```
public Opt<BigDecimal> avg(Function<? super T,BigDecimal> mapper)
```
    计算 BigDecimal 类型的平均值并以四舍五入的方式保留2位精度
    
    参数:
    
    mapper - 将对象转换为BigDecimal的 Function
    
    返回:
    
    计算后的平均值如果流的长度为0, 返回 Opt.empty()
  - avg
```
public Opt<BigDecimal> avg(Function<? super T,BigDecimal> mapper,
                           int scale)
```
    BigDecimal 类型的平均值并以四舍五入的方式保留小数点后scale位
    
    参数:
    
    mapper - 将对象转换为BigDecimal 的 Function
    
    scale - 保留精度
    
    返回:
    
    计算后的平均值如果流的长度为0, 返回 Opt.empty()
  - avg
```
public Opt<BigDecimal> avg(Function<? super T,BigDecimal> mapper,
                           int scale,
                           RoundingMode roundingMode)
```
    计算 BigDecimal 类型的平均值
    
    参数:
    
    mapper - 将对象转换为BigDecimal 的 Function
    
    scale - 保留精度
    
    roundingMode - 舍入模式
    
    返回:
    
    计算后的平均值如果元素的长度为0 那么会返回 Opt.empty()
  - avg
```
public OptionalDouble avg(ToIntFunction<? super T> mapper)
```
    计算int类型的平均值
    
    参数:
    
    mapper - 将对象转换为int 的 Function
    
    返回:
    
    OptionalDouble 如果流的长度为0 那么会返回OptionalDouble.empty()
  - avg
```
public OptionalDouble avg(ToDoubleFunction<? super T> mapper)
```
    计算double类型的平均值
    
    参数:
    
    mapper - 将对象转换为double 的 Function
    
    返回:
    
    OptionalDouble 如果流的长度为0 那么会返回OptionalDouble.empty()
  - avg
```
public OptionalDouble avg(ToLongFunction<? super T> mapper)
```
    计算double平均值
    
    参数:
    
    mapper - 将对象转换为long 的 Function
    
    返回:
    
    OptionalDouble 如果流的长度为0 那么会返回OptionalDouble.empty()

类 EasyStream<T>

嵌套类概要

字段概要

从类继承的字段 org.dromara.hutool.core.stream.AbstractEnhancedWrappedStream

从接口继承的字段 org.dromara.hutool.core.stream.WrappedStream

方法概要

从类继承的方法 org.dromara.hutool.core.stream.AbstractEnhancedWrappedStream

从类继承的方法 java.lang.Object

从接口继承的方法 org.dromara.hutool.core.stream.TerminableWrappedStream

从接口继承的方法 org.dromara.hutool.core.stream.TransformableWrappedStream

从接口继承的方法 org.dromara.hutool.core.stream.WrappedStream

方法详细资料

builder

empty

of

of

of

of

of

iterate

iterate

generate

concat

split

map

wrap

sum

sum

sum

sum

avg

avg

avg

avg

avg

avg