Steam (stream-core 1.4.3 API)

java.lang.Object
- org.dromara.stream.core.stream.Steam<T>

所有已实现的接口:

AutoCloseable, Iterable<T>, BaseStream<T,Stream<T>>, Stream<T>, CollectableStream<T>
```
public class Steam<T>
extends Object
implements Stream<T>, Iterable<T>, CollectableStream<T>
```
对Stream的封装和拓展，作者经对比了vavr、eclipse-collection、stream-ex以及其他语言的api，结合日常使用习惯，进行封装和拓展 Stream为集合提供了一些易用api，它让开发人员能使用声明式编程的方式去编写代码它分为中间操作和结束操作中间操作分为
- 无状态中间操作: 表示不用等待所有元素的当前操作执行完就可以执行的操作，不依赖之前历史操作的流的状态
- 有状态中间操作: 表示需要等待所有元素的当前操作执行完才能执行的操作,依赖之前历史操作的流的状态
结束操作分为
- 短路结束操作: 表示不用等待所有元素的当前操作执行完就可以执行的操作
- 非短路结束操作: 表示需要等待所有元素的当前操作执行完才能执行的操作
流只有在结束操作时才会真正触发执行以往的中间操作
它分为串行流和并行流并行流会使用拆分器Spliterator将操作拆分为多个异步任务ForkJoinTask执行这些异步任务默认使用ForkJoinPool线程池进行管理
作者:

VampireAchao Cizai_

另请参阅:

Stream

嵌套类概要

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

static interface Steam.Builder<T>

嵌套类
限定符和类型	类和说明
`static interface`	`Steam.Builder<T>`

字段概要

字段
限定符和类型	字段和说明
`protected static int`	`NOT_FOUND_INDEX` 代表不存在的下标, 一般用于并行流的下标, 或者未找到元素时的下标
`protected Stream<T>`	`stream` 原始的流实例

方法概要

所有方法静态方法实例方法具体方法
限定符和类型	方法和说明
`boolean`	`allMatch(Predicate<? super T> predicate)` 判断是否所有元素满足给定断言
`boolean`	`anyMatch(Predicate<? super T> predicate)` 判断是否有任何一个元素满足给定断言
`Optional<T>`	`at(Integer idx)` 获取流中指定下标的元素，如果是负数，则从最后一个开始数起
`static <T> Steam.Builder<T>`	`builder()` 返回`Steam`的建造器
`void`	`close()` 关闭流
`<R,A> R`	`collect(Collector<? super T,A,R> collector)` 对元素进行收集，并返回收集后的元素这是一个终端操作
`<R> R`	`collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)` 对元素进行收集，并返回收集后的容器这是一个终端操作
`static <T> Steam<T>`	`concat(Iterable<? extends T> a, Iterable<? extends T> b)` 创建一个惰性拼接流，其元素是第一个流的所有元素，然后是第二个流的所有元素。
`static <T> Steam<T>`	`concat(Stream<? extends T> a, Stream<? extends T> b)` 创建一个惰性拼接流，其元素是第一个流的所有元素，然后是第二个流的所有元素。
`long`	`count()` 返回流元素个数
`I`	`distinct()` 返回一个具有去重特征的流非并行流(顺序流)下对于重复元素，保留遇到顺序中最先出现的元素，并行流情况下不能保证具体保留哪一个这是一个有状态中间操作
`<F> Steam<T>`	`distinct(Function<? super T,F> keyExtractor)` 返回一个具有去重特征的流非并行流(顺序流)下对于重复元素，保留遇到顺序中最先出现的元素，并行流情况下不能保证具体保留哪一个这是一个有状态中间操作
`static <T> Steam<T>`	`empty()` 返回空的串行流
`boolean`	`equals(Object obj)` equals
`<R> Steam<T>`	`filter(Function<? super T,? extends R> mapper, R value)` 过滤元素，返回与指定操作结果匹配指定值的元素组成的流这是一个无状态中间操作
`I`	`filter(Predicate<? super T> predicate)` 过滤元素，返回与指定断言匹配的元素组成的流这是一个无状态中间操作
`<R> Steam<T>`	`filterContains(Function<? super T,? extends R> mapper, Iterable<T> others)` 过滤同类型集合中某一操作相同值的数据 `filter(Function, Object)`
`Steam<T>`	`filterIdx(BiPredicate<? super T,Integer> predicate)` 过滤元素，返回与指定断言匹配的元素组成的流，断言带下标
`Optional<T>`	`findAny()` 考虑性能，随便取一个，这里不是随机取一个，是随便取一个
`Optional<T>`	`findFirst()` 获取第一个元素
`Optional<T>`	`findFirst(Predicate<? super T> predicate)` 获取与给定断言匹配的第一个元素
`Integer`	`findFirstIdx(Predicate<? super T> predicate)` 获取与给定断言匹配的第一个元素的下标，并行流下标永远为-1
`Optional<T>`	`findLast()` 获取最后一个元素
`Optional<T>`	`findLast(Predicate<? super T> predicate)` 获取与给定断言匹配的最后一个元素
`Integer`	`findLastIdx(Predicate<? super T> predicate)` 获取与给定断言匹配的最后一个元素的下标，并行流下标永远为-1
`<R> Steam<R>`	`flat(Function<? super T,? extends Iterable<? extends R>> mapper)` 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作例如，将users里所有user的id和parentId组合在一起，形成一个新的流: `Steam<Long> ids = Steam.of(users).flatMap(user -> Steam.of(user.getId(), user.getParentId()));`
`<R> Steam<R>`	`flatIdx(BiFunction<? super T,Integer,? extends Iterable<? extends R>> mapper)` 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流，操作带下标，并行流时下标永远为-1 这是一个无状态中间操作
`<R> Steam<R>`	`flatMap(Function<? super T,? extends Stream<? extends R>> mapper)` 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作例如，将users里所有user的id和parentId组合在一起，形成一个新的流: `Steam<Long> ids = Steam.of(users).flatMap(user -> Steam.of(user.getId(), user.getParentId()));`
`DoubleStream`	`flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)` 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
`IntStream`	`flatMapToInt(Function<? super T,? extends IntStream> mapper)` 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
`LongStream`	`flatMapToLong(Function<? super T,? extends LongStream> mapper)` 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
`void`	`forEach(Consumer<? super T> action)` 对流里面的每一个元素执行一个操作这是一个终端操作
`void`	`forEachIdx(BiConsumer<? super T,Integer> action)` 对流里面的每一个元素执行一个操作，操作带下标，并行流时下标永远为-1 这是一个终端操作
`void`	`forEachOrdered(Consumer<? super T> action)` 对流里面的每一个元素按照顺序执行一个操作这是一个终端操作
`void`	`forEachOrderedIdx(BiConsumer<? super T,Integer> action)` 对流里面的每一个元素按照顺序执行一个操作，操作带下标，并行流时下标永远为-1 这是一个终端操作
`static <T> Steam<T>`	`generate(Supplier<T> s)` 返回无限串行无序流其中每一个元素都由给定的`Supplier`生成适用场景在一些生成常量流、随机元素等
`int`	`hashCode()` hashcode
`boolean`	`isParallel()` 返回流的并行状态
`static <T> Steam<T>`	`iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)` 返回无限有序流该流由初始值然后判断条件以及执行迭代函数进行迭代获取到元素例如 `Steam.iterate(0, i -> i < 3, i -> ++i)` 就可以创建包含元素0,1,2的流，使用`AbstractStreamWrapper.limit(long)`可以限制元素个数
`static <T> Steam<T>`	`iterate(T seed, UnaryOperator<T> f)` 返回无限有序流该流由初始值以及执行迭代函数进行迭代获取到元素例如 `Steam.iterate(0, i -> i + 1)` 就可以创建从0开始，每次+1的无限流，使用`AbstractStreamWrapper.limit(long)`可以限制元素个数
`Iterator<T>`	`iterator()` 返回流的迭代器
`I`	`limit(long maxSize)` 返回截取后面一些元素的流这是一个短路状态中间操作
`Steam<T>`	`log()` 返回叠加调用`PrintStream.println(Object)`打印出结果的流
`<R> Steam<R>`	`map(Function<? super T,? extends R> mapper)` 返回与指定函数将元素作为参数执行的结果组成的流这是一个无状态中间操作
`<R> Steam<R>`	`mapIdx(BiFunction<? super T,Integer,? extends R> mapper)` 返回与指定函数将元素作为参数执行的结果组成的流，操作带下标
`<R> Steam<R>`	`mapMulti(BiConsumer<? super T,? super Consumer<R>> mapper)` 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流，操作带一个方法，调用该方法可增加元素这是一个无状态中间操作
`DoubleStream`	`mapToDouble(ToDoubleFunction<? super T> mapper)` 和`Stream.map(Function)`一样，只不过函数的返回值必须为double类型这是一个无状态中间操作
`IntStream`	`mapToInt(ToIntFunction<? super T> mapper)` 和`Stream.map(Function)`一样，只不过函数的返回值必须为int类型这是一个无状态中间操作
`LongStream`	`mapToLong(ToLongFunction<? super T> mapper)` 和`Stream.map(Function)`一样，只不过函数的返回值必须为long类型这是一个无状态中间操作
`Optional<T>`	`max(Comparator<? super T> comparator)` 获取最大值
`Optional<T>`	`min(Comparator<? super T> comparator)` 获取最小值
`boolean`	`noneMatch(Predicate<? super T> predicate)` 判断是否没有元素满足给定断言
`Steam<T>`	`nonNull()` 过滤掉空元素
`static <T> Steam<T>`	`of(Iterable<T> iterable)` 通过实现了`Iterable`接口的对象创建串行流
`static <T> Steam<T>`	`of(Iterable<T> iterable, boolean parallel)` 通过传入的`Iterable`创建流
`static <T> Steam<T>`	`of(Stream<T> stream)` 通过传入的`Stream`创建流
`static <T> Steam<T>`	`of(T... values)` 返回包含指定元素的串行流
`static <T> Steam<T>`	`of(T t)` 返回包含单个元素的串行流
`I`	`onClose(Runnable closeHandler)` 在流关闭时执行操作
`I`	`parallel()` 将流转换为并行
`Steam<T>`	`parallel(boolean parallel)` 更改流的并行状态
`I`	`peek(Consumer<? super T> action)` 返回与指定函数将元素作为参数执行后组成的流。
`Steam<T>`	`peekIdx(SerBiCons<? super T,Integer> action)` peekIdx.
`Steam<T>`	`push(T... obj)` 与给定元素组成的流合并，成为新的流
`Steam<T>`	`push(T obj)` 与给定元素组成的流合并，成为新的流
`Optional<T>`	`reduce(BinaryOperator<T> accumulator)` 对元素进行聚合，并返回聚合后用 `Optional`包裹的值，相当于在for循环里写sum=sum+ints[i] 该操作相当于： {@code boolean foundAny = false; T result = null; for (T element : this stream) { if (!
`T`	`reduce(T identity, BinaryOperator<T> accumulator)` 对元素进行聚合，并返回聚合后的值，相当于在for循环里写sum=sum+ints[i] 这是一个终端操作求和、最小值、最大值、平均值和转换成一个String字符串均为聚合操作例如这里对int进行求和可以写成： `Integer sum = integers.reduce(0, (a, b) -> a+b);` 或者写成: `Integer sum = integers.reduce(0, Integer::sum);`
`<U> U`	`reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)` 对元素进行聚合，并返回聚合后的值，并行流时聚合拿到的初始值不稳定这是一个终端操作
`Steam<T>`	`reverseSorted(Comparator<T> comparator)` 反转顺序
`I`	`sequential()` 返回一个串行流，该方法可以将并行流转换为串行流
`I`	`skip(long n)` 返回丢弃前面n个元素后的剩余元素组成的流，如果当前元素个数小于n，则返回一个元素为空的流这是一个有状态中间操作
`I`	`sorted()` 返回一个元素按自然顺序排序的流如果此流的元素不是`Comparable` ，则在执行终端操作时可能会抛出 `java.lang.ClassCastException` 对于顺序流，排序是稳定的。
`I`	`sorted(Comparator<? super T> comparator)` 返回一个元素按指定的`Comparator`排序的流如果此流的元素不是`Comparable` ，则在执行终端操作时可能会抛出`java.lang.ClassCastException` 对于顺序流，排序是稳定的。
`Steam<T>`	`splice(int start, int deleteCount, T... items)` 类似js的splice函数
`Steam<Steam<T>>`	`split(int batchSize)` 按指定长度切分为双层流形如：[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
`static <T extends CharSequence> Steam<String>`	`split(T str, String regex)` 拆分字符串，转换为串行流
`Spliterator<T>`	`spliterator()` 返回流的拆分器
`Steam<List<T>>`	`splitList(int batchSize)` 按指定长度切分为元素为list的流形如：[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
`Object[]`	`toArray()` 返回一个包含此流元素的数组这是一个终端操作
`<A> A[]`	`toArray(IntFunction<A[]> generator)` 返回一个包含此流元素的指定的数组，例如以下代码编译正常，但运行时会抛出 `ArrayStoreException` {@code String[] strings = Stream.
`String`	`toString()` toString
`I`	`unordered()` 返回一个无序流(无手动排序) 标记一个流是不在意元素顺序的, 在并行流的某些情况下可以提高性能
`Steam<T>`	`unshift(T... obj)` 给定元素组成的流与当前流合并，成为新的流
`Steam<T>`	`unshift(T obj)` 给定元素组成的流与当前流合并，成为新的流
`protected Steam<T>`	`wrap(Stream<T> stream)` 构建一个`Steam`实例
`<U,R> Steam<R>`	`zip(Iterable<U> other, BiFunction<? super T,? super U,? extends R> zipper)` 将现有元素与给定迭代器中对应位置的元素使用 zipper 转换为新的元素，并返回新元素组成的流新流的数量等于旧流元素的数量使用 zipper 转换时, 如果对应位置上已经没有other元素，则other元素为null

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

从接口继承的方法 java.lang.Iterable
forEach, iterator, spliterator

从接口继承的方法 org.dromara.stream.core.stream.CollectableStream
group, group, group, join, join, join, partition, partition, partition, toCollection, toIdxMap, toIdxMap, toList, toMap, toMap, toMap, toMap, toSet, toUnmodifiableList, toUnmodifiableMap, toUnmodifiableMap, toUnmodifiableSet, toZip

从接口继承的方法 java.util.stream.Stream
allMatch, anyMatch, collect, collect, count, distinct, filter, findAny, findFirst, flatMapToDouble, flatMapToInt, flatMapToLong, forEach, forEachOrdered, limit, mapToDouble, mapToInt, mapToLong, max, min, noneMatch, peek, reduce, reduce, reduce, skip, sorted, sorted, toArray, toArray

从接口继承的方法 java.util.stream.BaseStream
close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered

- 字段详细资料
  - NOT_FOUND_INDEX
```
protected static final int NOT_FOUND_INDEX
```
    代表不存在的下标, 一般用于并行流的下标, 或者未找到元素时的下标
    
    另请参阅:
    
    常量字段值
  - stream
```
protected Stream<T> stream
```
    原始的流实例
- 方法详细资料
  - builder
```
public static <T> Steam.Builder<T> builder()
```
    返回Steam的建造器
    
    指定者:
    
    builder 在接口中 Stream<T>
    
    类型参数:
    
    T - 元素的类型
    
    返回:
    
    a stream builder
  - empty
```
public static <T> Steam<T> empty()
```
    返回空的串行流
    
    指定者:
    
    empty 在接口中 Stream<T>
    
    类型参数:
    
    T - 元素类型
    
    返回:
    
    一个空的串行流
  - of
```
public static <T> Steam<T> of(T t)
```
    返回包含单个元素的串行流
    
    指定者:
    
    of 在接口中 Stream<T>
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    t - 单个元素
    
    返回:
    
    包含单个元素的串行流
  - of
```
@SafeVarargs
public static <T> Steam<T> of(T... values)
```
    返回包含指定元素的串行流
    
    指定者:
    
    of 在接口中 Stream<T>
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    values - 指定元素
    
    返回:
    
    包含指定元素的串行流从一个安全数组中创建流
  - iterate
```
public static <T> Steam<T> iterate(T seed,
                                   UnaryOperator<T> f)
```
    返回无限有序流该流由初始值以及执行迭代函数进行迭代获取到元素
    例如 Steam.iterate(0, i -> i + 1) 就可以创建从0开始，每次+1的无限流，使用AbstractStreamWrapper.limit(long)可以限制元素个数
    
    指定者:
    
    iterate 在接口中 Stream<T>
  - iterate
```
public static <T> Steam<T> iterate(T seed,
                                   Predicate<? super T> hasNext,
                                   UnaryOperator<T> next)
```
    返回无限有序流该流由初始值然后判断条件以及执行迭代函数进行迭代获取到元素
    例如 Steam.iterate(0, i -> i < 3, i -> ++i) 就可以创建包含元素0,1,2的流，使用AbstractStreamWrapper.limit(long)可以限制元素个数
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    seed - 初始值
    
    hasNext - 条件值
    
    next - 用上一个元素作为参数执行并返回一个新的元素
    
    返回:
    
    无限有序流
  - generate
```
public static <T> Steam<T> generate(Supplier<T> s)
```
    返回无限串行无序流其中每一个元素都由给定的Supplier生成适用场景在一些生成常量流、随机元素等
    
    指定者:
    
    generate 在接口中 Stream<T>
  - concat
```
public static <T> Steam<T> concat(Stream<? extends T> a,
                                  Stream<? extends T> b)
```
    创建一个惰性拼接流，其元素是第一个流的所有元素，然后是第二个流的所有元素。如果两个输入流都是有序的，则结果流是有序的，如果任一输入流是并行的，则结果流是并行的。当结果流关闭时，两个输入流的关闭处理程序都会被调用。
    从重复串行流进行拼接时可能会导致深度调用链甚至抛出 StackOverflowException
    
    指定者:
    
    concat 在接口中 Stream<T>
  - concat
```
public static <T> Steam<T> concat(Iterable<? extends T> a,
                                  Iterable<? extends T> b)
```
    创建一个惰性拼接流，其元素是第一个流的所有元素，然后是第二个流的所有元素。如果两个输入流都是有序的，则结果流是有序的，如果任一输入流是并行的，则结果流是并行的。当结果流关闭时，两个输入流的关闭处理程序都会被调用。
    从重复串行流进行拼接时可能会导致深度调用链甚至抛出 StackOverflowException
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    a - 第一个流
    
    b - 第二个流
    
    返回:
    
    拼接后的流
  - of
```
public static <T> Steam<T> of(Iterable<T> iterable)
```
    通过实现了Iterable接口的对象创建串行流
    
    指定者:
    
    of 在接口中 Stream<T>
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    iterable - 实现了Iterable接口的对象
    
    返回:
    
    流
  - of
```
public static <T> Steam<T> of(Iterable<T> iterable,
                              boolean parallel)
```
    通过传入的Iterable创建流
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    iterable - Iterable
    
    parallel - 是否并行
    
    返回:
    
    流
  - of
```
public static <T> Steam<T> of(Stream<T> stream)
```
    通过传入的Stream创建流
    
    指定者:
    
    of 在接口中 Stream<T>
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    stream - Stream
    
    返回:
    
    流
  - split
```
public static <T extends CharSequence> Steam<String> split(T str,
                                                           String regex)
```
    拆分字符串，转换为串行流
    
    类型参数:
    
    T - a T class
    
    参数:
    
    str - 字符串
    
    regex - 正则
    
    返回:
    
    拆分后元素组成的流
  - filter
```
public <R> Steam<T> filter(Function<? super T,? extends R> mapper,
                           R value)
```
    过滤元素，返回与指定操作结果匹配指定值的元素组成的流这是一个无状态中间操作
    
    类型参数:
    
    R - 返回类型
    
    参数:
    
    mapper - 操作
    
    value - 用来匹配的值
    
    返回:
    
    与指定操作结果匹配指定值的元素组成的流
  - filterIdx
```
public Steam<T> filterIdx(BiPredicate<? super T,Integer> predicate)
```
    过滤元素，返回与指定断言匹配的元素组成的流，断言带下标
    
    参数:
    
    predicate - 断言
    
    返回:
    
    返回叠加过滤操作后的流
  - nonNull
```
public Steam<T> nonNull()
```
    过滤掉空元素
    
    返回:
    
    过滤后的流
  - map
```
public <R> Steam<R> map(Function<? super T,? extends R> mapper)
```
    返回与指定函数将元素作为参数执行的结果组成的流这是一个无状态中间操作
    
    指定者:
    
    map 在接口中 Stream<T>
  - mapIdx
```
public <R> Steam<R> mapIdx(BiFunction<? super T,Integer,? extends R> mapper)
```
    返回与指定函数将元素作为参数执行的结果组成的流，操作带下标
    
    类型参数:
    
    R - 函数执行后返回的类型
    
    参数:
    
    mapper - 指定的函数
    
    返回:
    
    返回叠加操作后的流
  - peekIdx
```
public Steam<T> peekIdx(SerBiCons<? super T,Integer> action)
```
    peekIdx.
    
    参数:
    
    action - a SerBiCons object
    
    返回:
    
    a Steam object
  - flatMap
```
public <R> Steam<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
```
    扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作例如，将users里所有user的id和parentId组合在一起，形成一个新的流:
```
     Steam<Long> ids = Steam.of(users).flatMap(user -> Steam.of(user.getId(), user.getParentId()));
 
```
    指定者:
    
    flatMap 在接口中 Stream<T>
  - flatIdx
```
public <R> Steam<R> flatIdx(BiFunction<? super T,Integer,? extends Iterable<? extends R>> mapper)
```
    扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流，操作带下标，并行流时下标永远为-1 这是一个无状态中间操作
    
    类型参数:
    
    R - 拆分后流的元素类型
    
    参数:
    
    mapper - 操作，返回流
    
    返回:
    
    返回叠加拆分操作后的流
  - flat
```
public <R> Steam<R> flat(Function<? super T,? extends Iterable<? extends R>> mapper)
```
    扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作例如，将users里所有user的id和parentId组合在一起，形成一个新的流:
```
     Steam<Long> ids = Steam.of(users).flatMap(user -> Steam.of(user.getId(), user.getParentId()));
 
```
    类型参数:
    
    R - 拆分后流的元素类型
    
    参数:
    
    mapper - 操作，返回可迭代对象
    
    返回:
    
    返回叠加拆分操作后的流
  - mapMulti
```
public <R> Steam<R> mapMulti(BiConsumer<? super T,? super Consumer<R>> mapper)
```
    扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流，操作带一个方法，调用该方法可增加元素这是一个无状态中间操作
    
    类型参数:
    
    R - 拆分后流的元素类型
    
    参数:
    
    mapper - 操作，返回流
    
    返回:
    
    返回叠加拆分操作后的流
  - distinct
```
public <F> Steam<T> distinct(Function<? super T,F> keyExtractor)
```
    返回一个具有去重特征的流非并行流(顺序流)下对于重复元素，保留遇到顺序中最先出现的元素，并行流情况下不能保证具体保留哪一个这是一个有状态中间操作
    
    类型参数:
    
    F - a F class
    
    参数:
    
    keyExtractor - 去重依据
    
    返回:
    
    一个具有去重特征的流
  - log
```
public Steam<T> log()
```
    返回叠加调用PrintStream.println(Object)打印出结果的流
    
    返回:
    
    返回叠加操作后的Steam
  - forEachIdx
```
public void forEachIdx(BiConsumer<? super T,Integer> action)
```
    对流里面的每一个元素执行一个操作，操作带下标，并行流时下标永远为-1 这是一个终端操作
    
    参数:
    
    action - 操作
  - forEachOrderedIdx
```
public void forEachOrderedIdx(BiConsumer<? super T,Integer> action)
```
    对流里面的每一个元素按照顺序执行一个操作，操作带下标，并行流时下标永远为-1 这是一个终端操作
    
    参数:
    
    action - 操作
  - findFirst
```
public Optional<T> findFirst(Predicate<? super T> predicate)
```
    获取与给定断言匹配的第一个元素
    
    参数:
    
    predicate - 断言
    
    返回:
    
    与给定断言匹配的第一个元素
  - findFirstIdx
```
public Integer findFirstIdx(Predicate<? super T> predicate)
```
    获取与给定断言匹配的第一个元素的下标，并行流下标永远为-1
    
    参数:
    
    predicate - 断言
    
    返回:
    
    与给定断言匹配的第一个元素的下标，如果不存在则返回-1
  - findLast
```
public Optional<T> findLast()
```
    获取最后一个元素
    
    返回:
    
    最后一个元素
  - findLast
```
public Optional<T> findLast(Predicate<? super T> predicate)
```
    获取与给定断言匹配的最后一个元素
    
    参数:
    
    predicate - 断言
    
    返回:
    
    与给定断言匹配的最后一个元素
  - findLastIdx
```
public Integer findLastIdx(Predicate<? super T> predicate)
```
    获取与给定断言匹配的最后一个元素的下标，并行流下标永远为-1
    
    参数:
    
    predicate - 断言
    
    返回:
    
    与给定断言匹配的最后一个元素的下标，如果不存在则返回-1
  - reverseSorted
```
public Steam<T> reverseSorted(Comparator<T> comparator)
```
    反转顺序
    
    参数:
    
    comparator - a Comparator object
    
    返回:
    
    反转排序顺序
  - parallel
```
public Steam<T> parallel(boolean parallel)
```
    更改流的并行状态
    
    参数:
    
    parallel - 是否并行
    
    返回:
    
    流
  - push
```
public Steam<T> push(T obj)
```
    与给定元素组成的流合并，成为新的流
    
    参数:
    
    obj - 元素
    
    返回:
    
    流
  - push
```
public Steam<T> push(T... obj)
```
    与给定元素组成的流合并，成为新的流
    
    参数:
    
    obj - 元素
    
    返回:
    
    流
  - unshift
```
public Steam<T> unshift(T obj)
```
    给定元素组成的流与当前流合并，成为新的流
    
    参数:
    
    obj - 元素
    
    返回:
    
    流
  - unshift
```
@SafeVarargs
public final Steam<T> unshift(T... obj)
```
    给定元素组成的流与当前流合并，成为新的流
    
    参数:
    
    obj - 元素
    
    返回:
    
    流
  - at
```
public Optional<T> at(Integer idx)
```
    获取流中指定下标的元素，如果是负数，则从最后一个开始数起
    
    参数:
    
    idx - 下标
    
    返回:
    
    指定下标的元素
  - wrap
```
protected Steam<T> wrap(Stream<T> stream)
```
    构建一个Steam实例
    
    参数:
    
    stream - 流
    
    返回:
    
    实现类
  - hashCode
```
public int hashCode()
```
    hashcode
    
    覆盖:
    
    hashCode 在类中 Object
  - equals
```
public boolean equals(Object obj)
```
    equals
    
    覆盖:
    
    equals 在类中 Object
  - toString
```
public String toString()
```
    toString
    
    覆盖:
    
    toString 在类中 Object
  - zip
```
public <U,R> Steam<R> zip(Iterable<U> other,
                          BiFunction<? super T,? super U,? extends R> zipper)
```
    将现有元素与给定迭代器中对应位置的元素使用 zipper 转换为新的元素，并返回新元素组成的流
    新流的数量等于旧流元素的数量
    使用 zipper 转换时, 如果对应位置上已经没有other元素，则other元素为null
    
    类型参数:
    
    U - 给定的迭代对象类型
    
    R - 合并后的结果对象类型
    
    参数:
    
    other - 给定的迭代器
    
    zipper - 两个元素的合并器
    
    返回:
    
    合并后的结果对象的流
  - filterContains
```
public <R> Steam<T> filterContains(Function<? super T,? extends R> mapper,
                                   Iterable<T> others)
```
    过滤同类型集合中某一操作相同值的数据 filter(Function, Object)
    
    类型参数:
    
    R - 操作返回值类型
    
    参数:
    
    others - 另一可迭代对象
    
    mapper - 操作
    
    返回:
    
    过滤同类型集合中某一操作相同值的数据
  - splice
```
public Steam<T> splice(int start,
                       int deleteCount,
                       T... items)
```
    类似js的splice函数
    
    参数:
    
    start - 起始下标
    
    deleteCount - 删除个数，正整数
    
    items - 放入值
    
    返回:
    
    操作后的流
  - split
```
public Steam<Steam<T>> split(int batchSize)
```
    按指定长度切分为双层流
    形如：[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
    
    参数:
    
    batchSize - 指定长度, 正整数
    
    返回:
    
    切好的流
  - splitList
```
public Steam<List<T>> splitList(int batchSize)
```
    按指定长度切分为元素为list的流
    形如：[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
    
    参数:
    
    batchSize - 指定长度, 正整数
    
    返回:
    
    切好的流
  - filter
```
public I filter(Predicate<? super T> predicate)
```
    过滤元素，返回与指定断言匹配的元素组成的流这是一个无状态中间操作
    
    指定者:
    
    filter 在接口中 Stream<T>
  - mapToInt
```
public IntStream mapToInt(ToIntFunction<? super T> mapper)
```
    和Stream.map(Function)一样，只不过函数的返回值必须为int类型这是一个无状态中间操作
    
    指定者:
    
    mapToInt 在接口中 Stream<T>
  - mapToLong
```
public LongStream mapToLong(ToLongFunction<? super T> mapper)
```
    和Stream.map(Function)一样，只不过函数的返回值必须为long类型这是一个无状态中间操作
    
    指定者:
    
    mapToLong 在接口中 Stream<T>
  - mapToDouble
```
public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)
```
    和Stream.map(Function)一样，只不过函数的返回值必须为double类型这是一个无状态中间操作
    
    指定者:
    
    mapToDouble 在接口中 Stream<T>
  - flatMapToInt
```
public IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper)
```
    扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
    
    指定者:
    
    flatMapToInt 在接口中 Stream<T>
  - flatMapToLong
```
public LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper)
```
    扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
    
    指定者:
    
    flatMapToLong 在接口中 Stream<T>
  - flatMapToDouble
```
public DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
```
    扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
    
    指定者:
    
    flatMapToDouble 在接口中 Stream<T>
  - distinct
```
public I distinct()
```
    返回一个具有去重特征的流非并行流(顺序流)下对于重复元素，保留遇到顺序中最先出现的元素，并行流情况下不能保证具体保留哪一个这是一个有状态中间操作
    
    指定者:
    
    distinct 在接口中 Stream<T>
  - sorted
```
public I sorted()
```
    返回一个元素按自然顺序排序的流如果此流的元素不是Comparable ，则在执行终端操作时可能会抛出 java.lang.ClassCastException 对于顺序流，排序是稳定的。对于无序流，没有稳定性保证。这是一个有状态中间操作
    
    指定者:
    
    sorted 在接口中 Stream<T>
  - sorted
```
public I sorted(Comparator<? super T> comparator)
```
    返回一个元素按指定的Comparator排序的流如果此流的元素不是Comparable ，则在执行终端操作时可能会抛出java.lang.ClassCastException 对于顺序流，排序是稳定的。对于无序流，没有稳定性保证。这是一个有状态中间操作
    
    指定者:
    
    sorted 在接口中 Stream<T>
  - peek
```
public I peek(Consumer<? super T> action)
```
    返回与指定函数将元素作为参数执行后组成的流。这是一个无状态中间操作
    指定者:
    
    peek 在接口中 Stream<T>
    
    API Note:
    该方法存在的意义主要是用来调试当你需要查看经过操作管道某处的元素，可以执行以下操作:
    .of("one", "two", "three", "four") .filter(e -> e.length() > 3) .peek(e -> System.out.println("Filtered value: " + e)) .map(String::toUpperCase) .peek(e -> System.out.println("Mapped value: " + e)) .collect(Collectors.toList());
  - limit
```
public I limit(long maxSize)
```
    返回截取后面一些元素的流这是一个短路状态中间操作
    
    指定者:
    
    limit 在接口中 Stream<T>
  - skip
```
public I skip(long n)
```
    返回丢弃前面n个元素后的剩余元素组成的流，如果当前元素个数小于n，则返回一个元素为空的流这是一个有状态中间操作
    
    指定者:
    
    skip 在接口中 Stream<T>
  - forEach
```
public void forEach(Consumer<? super T> action)
```
    对流里面的每一个元素执行一个操作这是一个终端操作
    
    指定者:
    
    forEach 在接口中 Iterable<T>
    
    指定者:
    
    forEach 在接口中 Stream<T>
  - forEachOrdered
```
public void forEachOrdered(Consumer<? super T> action)
```
    对流里面的每一个元素按照顺序执行一个操作这是一个终端操作
    
    指定者:
    
    forEachOrdered 在接口中 Stream<T>
  - toArray
```
public Object[] toArray()
```
    返回一个包含此流元素的数组这是一个终端操作
    
    指定者:
    
    toArray 在接口中 Stream<T>
  - toArray
```
public <A> A[] toArray(IntFunction<A[]> generator)
```
    返回一个包含此流元素的指定的数组，例如以下代码编译正常，但运行时会抛出 ArrayStoreException
```
 String[] strings = Stream.<Integer>builder().add(1).build().toArray(String[]::new); 
```
    指定者:
    
    toArray 在接口中 Stream<T>
  - reduce
```
public T reduce(T identity,
                BinaryOperator<T> accumulator)
```
    对元素进行聚合，并返回聚合后的值，相当于在for循环里写sum=sum+ints[i] 这是一个终端操作
    求和、最小值、最大值、平均值和转换成一个String字符串均为聚合操作例如这里对int进行求和可以写成：
```
     Integer sum = integers.reduce(0, (a, b) -> a+b);
 
```
    或者写成:
```
     Integer sum = integers.reduce(0, Integer::sum);
 
```
    指定者:
    
    reduce 在接口中 Stream<T>
  - reduce
```
public Optional<T> reduce(BinaryOperator<T> accumulator)
```
    对元素进行聚合，并返回聚合后用 Optional包裹的值，相当于在for循环里写sum=sum+ints[i] 该操作相当于：
```
     boolean foundAny = false;
     T result = null;
     for (T element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.apply(result, element);
     }
     return foundAny ? Optional.of(result) : Optional.empty();
 
```
    但它不局限于顺序执行，例如并行流等情况下这是一个终端操作
    例如以下场景抛出 NPE ：
```
      Optional<Integer> reduce = Stream.<Integer>builder().add(1).add(1).build().reduce((a, b) -> null);
 
```
    指定者:
    
    reduce 在接口中 Stream<T>
    
    另请参阅:
    
    reduce(Object, BinaryOperator), min(Comparator), max(Comparator)
  - reduce
```
public <U> U reduce(U identity,
                    BiFunction<U,? super T,U> accumulator,
                    BinaryOperator<U> combiner)
```
    对元素进行聚合，并返回聚合后的值，并行流时聚合拿到的初始值不稳定这是一个终端操作
    
    指定者:
    
    reduce 在接口中 Stream<T>
    
    另请参阅:
    
    reduce(BinaryOperator), reduce(Object, BinaryOperator)
  - collect
```
public <R> R collect(Supplier<R> supplier,
                     BiConsumer<R,? super T> accumulator,
                     BiConsumer<R,R> combiner)
```
    对元素进行收集，并返回收集后的容器这是一个终端操作
    
    指定者:
    
    collect 在接口中 Stream<T>
  - collect
```
public <R,A> R collect(Collector<? super T,A,R> collector)
```
    对元素进行收集，并返回收集后的元素这是一个终端操作
    
    指定者:
    
    collect 在接口中 Stream<T>
  - min
```
public Optional<T> min(Comparator<? super T> comparator)
```
    获取最小值
    
    指定者:
    
    min 在接口中 Stream<T>
  - max
```
public Optional<T> max(Comparator<? super T> comparator)
```
    获取最大值
    
    指定者:
    
    max 在接口中 Stream<T>
  - count
```
public long count()
```
    返回流元素个数
    
    指定者:
    
    count 在接口中 Stream<T>
  - anyMatch
```
public boolean anyMatch(Predicate<? super T> predicate)
```
    判断是否有任何一个元素满足给定断言
    
    指定者:
    
    anyMatch 在接口中 Stream<T>
  - allMatch
```
public boolean allMatch(Predicate<? super T> predicate)
```
    判断是否所有元素满足给定断言
    
    指定者:
    
    allMatch 在接口中 Stream<T>
  - noneMatch
```
public boolean noneMatch(Predicate<? super T> predicate)
```
    判断是否没有元素满足给定断言
    
    指定者:
    
    noneMatch 在接口中 Stream<T>
  - findFirst
```
public Optional<T> findFirst()
```
    获取第一个元素
    
    指定者:
    
    findFirst 在接口中 Stream<T>
  - findAny
```
public Optional<T> findAny()
```
    考虑性能，随便取一个，这里不是随机取一个，是随便取一个
    
    指定者:
    
    findAny 在接口中 Stream<T>
  - iterator
```
public Iterator<T> iterator()
```
    返回流的迭代器
    
    指定者:
    
    iterator 在接口中 Iterable<T>
    
    指定者:
    
    iterator 在接口中 BaseStream<T,Stream<T>>
  - spliterator
```
public Spliterator<T> spliterator()
```
    返回流的拆分器
    
    指定者:
    
    spliterator 在接口中 Iterable<T>
    
    指定者:
    
    spliterator 在接口中 BaseStream<T,Stream<T>>
  - isParallel
```
public boolean isParallel()
```
    返回流的并行状态
    
    指定者:
    
    isParallel 在接口中 BaseStream<T,Stream<T>>
  - sequential
```
public I sequential()
```
    返回一个串行流，该方法可以将并行流转换为串行流
    
    指定者:
    
    sequential 在接口中 BaseStream<T,Stream<T>>
  - parallel
```
public I parallel()
```
    将流转换为并行
    
    指定者:
    
    parallel 在接口中 BaseStream<T,Stream<T>>
  - unordered
```
public I unordered()
```
    返回一个无序流(无手动排序)
    标记一个流是不在意元素顺序的, 在并行流的某些情况下可以提高性能
    
    指定者:
    
    unordered 在接口中 BaseStream<T,Stream<T>>
  - onClose
```
public I onClose(Runnable closeHandler)
```
    在流关闭时执行操作
    
    指定者:
    
    onClose 在接口中 BaseStream<T,Stream<T>>
  - close
```
public void close()
```
    关闭流
    
    指定者:
    
    close 在接口中 AutoCloseable
    
    指定者:
    
    close 在接口中 BaseStream<T,Stream<T>>
    
    另请参阅:
    
    AutoCloseable.close()

类 Steam<T>

嵌套类概要

字段概要

方法概要

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

从接口继承的方法 java.lang.Iterable

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

从接口继承的方法 java.util.stream.Stream

从接口继承的方法 java.util.stream.BaseStream

字段详细资料

NOT_FOUND_INDEX

stream

方法详细资料

builder

empty

of

of

iterate

iterate

generate

concat

concat

of

of

of

split

filter

filterIdx

nonNull

map

mapIdx

peekIdx

flatMap

flatIdx

flat

mapMulti

distinct

log

forEachIdx

forEachOrderedIdx

findFirst

findFirstIdx

findLast

findLast

findLastIdx

reverseSorted

parallel

push

push

unshift

unshift

at

wrap

hashCode

equals

toString

zip

filterContains

splice

split

splitList

filter

mapToInt

mapToLong

mapToDouble

flatMapToInt

flatMapToLong

flatMapToDouble

distinct

sorted

sorted

peek

limit

skip

forEach

forEachOrdered

toArray

toArray

reduce

reduce