WrappedStream (hutool-core 6.0.0-M12 API)

类型参数:

T - 流中的元素类型

S - WrappedStream的实现类类型

所有超级接口:

AutoCloseable, BaseStream<T,Stream<T>>, Iterable<T>, Stream<T>

所有已知子接口:

TerminableWrappedStream<T,S>, TransformableWrappedStream<T,S>

所有已知实现类:

AbstractEnhancedWrappedStream, EasyStream, EntryStream
```
public interface WrappedStream<T,S extends WrappedStream<T,S>>
extends Stream<T>, Iterable<T>
```
Stream实例的包装器，用于增强原始的Stream，提供一些额外的中间与终端操作。
默认提供两个可用实现：
- EasyStream：针对单元素的通用增强流实现；
- EntryStream：针对键值对类型元素的增强流实现；
作者:

huangchengxing

从以下版本开始:

6.0.0

另请参阅:

TerminableWrappedStream, TransformableWrappedStream, AbstractEnhancedWrappedStream, EasyStream, EntryStream

嵌套类概要
- 从接口继承的嵌套类/接口 java.util.stream.Stream
  Stream.Builder<T>

字段概要

字段
限定符和类型字段和说明

static int NOT_FOUND_ELEMENT_INDEX
代表不存在的下标, 或者未找到元素时的下标

字段
限定符和类型	字段和说明
`static int`	`NOT_FOUND_ELEMENT_INDEX` 代表不存在的下标, 或者未找到元素时的下标

方法概要

所有方法实例方法抽象方法默认方法
限定符和类型	方法和说明
`default boolean`	`allMatch(Predicate<? super T> predicate)` 判断是否所有元素满足给定断言
`default boolean`	`anyMatch(Predicate<? super T> predicate)` 判断是否有任何一个元素满足给定断言
`default void`	`close()` 关闭流
`default <R,A> R`	`collect(Collector<? super T,A,R> collector)` 对元素进行收集，并返回收集后的元素这是一个终端操作
`default <R> R`	`collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)` 对元素进行收集，并返回收集后的容器这是一个终端操作
`default long`	`count()` 返回流元素个数
`default S`	`distinct()` 返回一个具有去重特征的流非并行流(顺序流)下对于重复元素，保留遇到顺序中最先出现的元素，并行流情况下不能保证具体保留哪一个这是一个有状态中间操作
`default EasyStream<T>`	`easyStream()` 转换为EasyStream
`boolean`	`equals(Object obj)` 比较实例是否相等
`default S`	`filter(Predicate<? super T> predicate)` 过滤元素，返回与指定断言匹配的元素组成的流这是一个无状态中间操作
`default Optional<T>`	`findAny()` 考虑性能，随便取一个，这里不是随机取一个，是随便取一个
`default Optional<T>`	`findFirst()` 获取第一个元素
`default DoubleStream`	`flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)` 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
`default IntStream`	`flatMapToInt(Function<? super T,? extends IntStream> mapper)` 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
`default LongStream`	`flatMapToLong(Function<? super T,? extends LongStream> mapper)` 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
`default void`	`forEach(Consumer<? super T> action)` 对流里面的每一个元素执行一个操作这是一个终端操作
`default void`	`forEachOrdered(Consumer<? super T> action)` 对流里面的每一个元素按照顺序执行一个操作这是一个终端操作
`int`	`hashCode()` 获取当前实例的哈希值
`default boolean`	`isParallel()` 返回流的并行状态
`default Iterator<T>`	`iterator()` 返回流的迭代器
`default S`	`limit(long maxSize)` 返回截取后面一些元素的流这是一个短路状态中间操作
`default DoubleStream`	`mapToDouble(ToDoubleFunction<? super T> mapper)` 和`EasyStream.map(Function)`一样，只不过函数的返回值必须为double类型这是一个无状态中间操作
`default IntStream`	`mapToInt(ToIntFunction<? super T> mapper)` 和`EasyStream.map(Function)`一样，只不过函数的返回值必须为int类型这是一个无状态中间操作
`default LongStream`	`mapToLong(ToLongFunction<? super T> mapper)` 和`EasyStream.map(Function)`一样，只不过函数的返回值必须为long类型这是一个无状态中间操作
`default Optional<T>`	`max(Comparator<? super T> comparator)` 获取最大值
`default Optional<T>`	`min(Comparator<? super T> comparator)` 获取最小值
`default boolean`	`noneMatch(Predicate<? super T> predicate)` 判断是否没有元素满足给定断言
`default S`	`onClose(Runnable closeHandler)` 在流关闭时执行操作
`default S`	`parallel()` 将流转换为并行
`default S`	`peek(Consumer<? super T> action)` 返回与指定函数将元素作为参数执行后组成的流。
`default Optional<T>`	`reduce(BinaryOperator<T> accumulator)` 对元素进行聚合，并返回聚合后用 `Optional`包裹的值，相当于在for循环里写sum=sum+ints[i] 该操作相当于： {@code boolean foundAny = false; T result = null; for (T element : this unwrap) { if (!
`default 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);`
`default <U> U`	`reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)` 对元素进行聚合，并返回聚合后的值，并行流时聚合拿到的初始值不稳定这是一个终端操作
`default S`	`sequential()` 返回一个串行流，该方法可以将并行流转换为串行流
`default S`	`skip(long n)` 返回丢弃前面n个元素后的剩余元素组成的流，如果当前元素个数小于n，则返回一个元素为空的流这是一个有状态中间操作
`default S`	`sorted()` 返回一个元素按自然顺序排序的流如果此流的元素不是`Comparable` ，则在执行终端操作时可能会抛出 `java.lang.ClassCastException` 对于顺序流，排序是稳定的。
`default S`	`sorted(Comparator<? super T> comparator)` 返回一个元素按指定的`Comparator`排序的流如果此流的元素不是`Comparable` ，则在执行终端操作时可能会抛出`java.lang.ClassCastException` 对于顺序流，排序是稳定的。
`default Spliterator<T>`	`spliterator()` 返回流的拆分器
`default Object[]`	`toArray()` 返回一个包含此流元素的数组这是一个终端操作
`default <A> A[]`	`toArray(IntFunction<A[]> generator)` 返回一个包含此流元素的指定的数组，例如以下代码编译正常，但运行时会抛出 `ArrayStoreException` {@code String[] strings = Stream.
`String`	`toString()` 将当前实例转为字符串
`default S`	`unordered()` 返回一个无序流(无手动排序) 标记一个流是不在意元素顺序的, 在并行流的某些情况下可以提高性能
`Stream<T>`	`unwrap()` 获取被当前实例包装的流对象
`S`	`wrap(Stream<T> source)` 将一个原始流包装为指定类型的增强流若`source`于当前实例包装的流并不相同，则该增强流与当前实例无关联关系

从接口继承的方法 java.util.stream.Stream
builder, concat, empty, flatMap, generate, iterate, map, of, of

- 字段详细资料
  - NOT_FOUND_ELEMENT_INDEX
```
static final int NOT_FOUND_ELEMENT_INDEX
```
    代表不存在的下标, 或者未找到元素时的下标
    
    另请参阅:
    
    常量字段值
- 方法详细资料
  - unwrap
```
Stream<T> unwrap()
```
    获取被当前实例包装的流对象
    
    返回:
    
    被当前实例包装的流对象
  - wrap
```
S wrap(Stream<T> source)
```
    将一个原始流包装为指定类型的增强流
    若source于当前实例包装的流并不相同，则该增强流与当前实例无关联关系
    
    参数:
    
    source - 被包装的流
    
    返回:
    
    包装后的流
  - filter
```
default S filter(Predicate<? super T> predicate)
```
    过滤元素，返回与指定断言匹配的元素组成的流这是一个无状态中间操作
    
    指定者:
    
    filter 在接口中 Stream<T>
    
    参数:
    
    predicate - 断言
    
    返回:
    
    返回叠加过滤操作后的流
  - mapToInt
```
default IntStream mapToInt(ToIntFunction<? super T> mapper)
```
    和EasyStream.map(Function)一样，只不过函数的返回值必须为int类型这是一个无状态中间操作
    
    指定者:
    
    mapToInt 在接口中 Stream<T>
    
    参数:
    
    mapper - 返回值为int类型的函数
    
    返回:
    
    叠加操作后元素类型全为int的流
  - mapToLong
```
default LongStream mapToLong(ToLongFunction<? super T> mapper)
```
    和EasyStream.map(Function)一样，只不过函数的返回值必须为long类型这是一个无状态中间操作
    
    指定者:
    
    mapToLong 在接口中 Stream<T>
    
    参数:
    
    mapper - 返回值为long类型的函数
    
    返回:
    
    叠加操作后元素类型全为long的流
  - mapToDouble
```
default DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)
```
    和EasyStream.map(Function)一样，只不过函数的返回值必须为double类型这是一个无状态中间操作
    
    指定者:
    
    mapToDouble 在接口中 Stream<T>
    
    参数:
    
    mapper - 返回值为double类型的函数
    
    返回:
    
    叠加操作后元素类型全为double的流
  - flatMapToInt
```
default IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper)
```
    扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
    
    指定者:
    
    flatMapToInt 在接口中 Stream<T>
    
    参数:
    
    mapper - 操作，返回IntStream
    
    返回:
    
    返回叠加拆分操作后的IntStream
  - flatMapToLong
```
default LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper)
```
    扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
    
    指定者:
    
    flatMapToLong 在接口中 Stream<T>
    
    参数:
    
    mapper - 操作，返回LongStream
    
    返回:
    
    返回叠加拆分操作后的LongStream
  - flatMapToDouble
```
default DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
```
    扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流这是一个无状态中间操作
    
    指定者:
    
    flatMapToDouble 在接口中 Stream<T>
    
    参数:
    
    mapper - 操作，返回DoubleStream
    
    返回:
    
    返回叠加拆分操作后的DoubleStream
  - distinct
```
default S distinct()
```
    返回一个具有去重特征的流非并行流(顺序流)下对于重复元素，保留遇到顺序中最先出现的元素，并行流情况下不能保证具体保留哪一个这是一个有状态中间操作
    
    指定者:
    
    distinct 在接口中 Stream<T>
    
    返回:
    
    一个具有去重特征的流
  - sorted
```
default S sorted()
```
    返回一个元素按自然顺序排序的流如果此流的元素不是Comparable ，则在执行终端操作时可能会抛出 java.lang.ClassCastException 对于顺序流，排序是稳定的。对于无序流，没有稳定性保证。这是一个有状态中间操作
    
    指定者:
    
    sorted 在接口中 Stream<T>
    
    返回:
    
    一个元素按自然顺序排序的流
  - sorted
```
default S sorted(Comparator<? super T> comparator)
```
    返回一个元素按指定的Comparator排序的流如果此流的元素不是Comparable ，则在执行终端操作时可能会抛出java.lang.ClassCastException 对于顺序流，排序是稳定的。对于无序流，没有稳定性保证。这是一个有状态中间操作
    
    指定者:
    
    sorted 在接口中 Stream<T>
    
    参数:
    
    comparator - 排序规则
    
    返回:
    
    一个元素按指定的Comparator排序的流
  - peek
```
default S 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());
    参数:
    
    action - 指定的函数
    
    返回:
    
    返回叠加操作后的FastStream
  - limit
```
default S limit(long maxSize)
```
    返回截取后面一些元素的流这是一个短路状态中间操作
    
    指定者:
    
    limit 在接口中 Stream<T>
    
    参数:
    
    maxSize - 元素截取后的个数
    
    返回:
    
    截取后的流
  - skip
```
default S skip(long n)
```
    返回丢弃前面n个元素后的剩余元素组成的流，如果当前元素个数小于n，则返回一个元素为空的流这是一个有状态中间操作
    
    指定者:
    
    skip 在接口中 Stream<T>
    
    参数:
    
    n - 需要丢弃的元素个数
    
    返回:
    
    丢弃前面n个元素后的剩余元素组成的流
  - forEach
```
default void forEach(Consumer<? super T> action)
```
    对流里面的每一个元素执行一个操作这是一个终端操作
    
    指定者:
    
    forEach 在接口中 Iterable<T>
    
    指定者:
    
    forEach 在接口中 Stream<T>
    
    参数:
    
    action - 操作
  - forEachOrdered
```
default void forEachOrdered(Consumer<? super T> action)
```
    对流里面的每一个元素按照顺序执行一个操作这是一个终端操作
    
    指定者:
    
    forEachOrdered 在接口中 Stream<T>
    
    参数:
    
    action - 操作
  - toArray
```
default Object[] toArray()
```
    返回一个包含此流元素的数组这是一个终端操作
    
    指定者:
    
    toArray 在接口中 Stream<T>
    
    返回:
    
    包含此流元素的数组
  - toArray
```
default <A> A[] toArray(IntFunction<A[]> generator)
```
    返回一个包含此流元素的指定的数组，例如以下代码编译正常，但运行时会抛出 ArrayStoreException
```
 String[] strings = Stream.<Integer>builder().add(1).build().toArray(String[]::new); 
```
    指定者:
    
    toArray 在接口中 Stream<T>
    
    类型参数:
    
    A - 给定的数组类型
    
    参数:
    
    generator - 这里的IntFunction的参数是元素的个数，返回值为数组类型
    
    返回:
    
    包含此流元素的指定的数组
    
    抛出:
    
    ArrayStoreException - 如果元素转换失败，例如不是该元素类型及其父类，则抛出该异常
  - reduce
```
default 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>
    
    参数:
    
    identity - 初始值，还用于限定泛型
    
    accumulator - 你想要的聚合操作
    
    返回:
    
    聚合计算后的值
  - reduce
```
default Optional<T> reduce(BinaryOperator<T> accumulator)
```
    对元素进行聚合，并返回聚合后用 Optional包裹的值，相当于在for循环里写sum=sum+ints[i] 该操作相当于：
```
     boolean foundAny = false;
     T result = null;
     for (T element : this unwrap) {
         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>
    
    参数:
    
    accumulator - 你想要的聚合操作
    
    返回:
    
    聚合后用 Optional包裹的值
    
    抛出:
    
    NullPointerException - 如果给定的聚合操作中执行后结果为空，并用于下一次执行，则抛出该异常
    
    另请参阅:
    
    reduce(Object, BinaryOperator), min(Comparator), max(Comparator)
  - reduce
```
default <U> U reduce(U identity,
                     BiFunction<U,? super T,U> accumulator,
                     BinaryOperator<U> combiner)
```
    对元素进行聚合，并返回聚合后的值，并行流时聚合拿到的初始值不稳定这是一个终端操作
    
    指定者:
    
    reduce 在接口中 Stream<T>
    
    类型参数:
    
    U - 初始值
    
    参数:
    
    identity - 初始值
    
    accumulator - 累加器，具体为你要的聚合操作
    
    combiner - 用于并行流时组合多个结果
    
    返回:
    
    聚合操作的结果
    
    另请参阅:
    
    reduce(BinaryOperator), reduce(Object, BinaryOperator)
  - collect
```
default <R> R collect(Supplier<R> supplier,
                      BiConsumer<R,? super T> accumulator,
                      BiConsumer<R,R> combiner)
```
    对元素进行收集，并返回收集后的容器这是一个终端操作
    指定者:
    
    collect 在接口中 Stream<T>
    
    类型参数:
    
    R - 用于收集元素的容器，大多是集合
    
    参数:
    
    supplier - 提供初始值的函数式接口，一般可以传入构造参数
    
    accumulator - 具体收集操作
    
    combiner - 用于并行流时组合多个结果
    
    返回:
    收集后的容器
    List<Integer> collect = Stream.iterate(1, i -> ++i).limit(10).collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
  - collect
```
default <R,A> R collect(Collector<? super T,A,R> collector)
```
    对元素进行收集，并返回收集后的元素这是一个终端操作
    
    指定者:
    
    collect 在接口中 Stream<T>
    
    类型参数:
    
    R - 容器类型
    
    A - 具体操作时容器类型，例如 List::add 时它为 List
    
    参数:
    
    collector - 收集器
    
    返回:
    
    收集后的容器
  - min
```
default Optional<T> min(Comparator<? super T> comparator)
```
    获取最小值
    
    指定者:
    
    min 在接口中 Stream<T>
    
    参数:
    
    comparator - 一个用来比较大小的比较器Comparator
    
    返回:
    
    最小值
  - max
```
default Optional<T> max(Comparator<? super T> comparator)
```
    获取最大值
    
    指定者:
    
    max 在接口中 Stream<T>
    
    参数:
    
    comparator - 一个用来比较大小的比较器Comparator
    
    返回:
    
    最大值
  - count
```
default long count()
```
    返回流元素个数
    
    指定者:
    
    count 在接口中 Stream<T>
    
    返回:
    
    流元素个数
  - anyMatch
```
default boolean anyMatch(Predicate<? super T> predicate)
```
    判断是否有任何一个元素满足给定断言
    
    指定者:
    
    anyMatch 在接口中 Stream<T>
    
    参数:
    
    predicate - 断言
    
    返回:
    
    是否有任何一个元素满足给定断言
  - allMatch
```
default boolean allMatch(Predicate<? super T> predicate)
```
    判断是否所有元素满足给定断言
    
    指定者:
    
    allMatch 在接口中 Stream<T>
    
    参数:
    
    predicate - 断言
    
    返回:
    
    是否所有元素满足给定断言
  - noneMatch
```
default boolean noneMatch(Predicate<? super T> predicate)
```
    判断是否没有元素满足给定断言
    
    指定者:
    
    noneMatch 在接口中 Stream<T>
    
    参数:
    
    predicate - 断言
    
    返回:
    
    是否没有元素满足给定断言
  - findFirst
```
default Optional<T> findFirst()
```
    获取第一个元素
    
    指定者:
    
    findFirst 在接口中 Stream<T>
    
    返回:
    
    第一个元素
  - findAny
```
default Optional<T> findAny()
```
    考虑性能，随便取一个，这里不是随机取一个，是随便取一个
    
    指定者:
    
    findAny 在接口中 Stream<T>
    
    返回:
    
    随便取一个
  - iterator
```
default Iterator<T> iterator()
```
    返回流的迭代器
    
    指定者:
    
    iterator 在接口中 BaseStream<T,Stream<T>>
    
    指定者:
    
    iterator 在接口中 Iterable<T>
    
    返回:
    
    流的迭代器
  - spliterator
```
default Spliterator<T> spliterator()
```
    返回流的拆分器
    
    指定者:
    
    spliterator 在接口中 BaseStream<T,Stream<T>>
    
    指定者:
    
    spliterator 在接口中 Iterable<T>
    
    返回:
    
    流的拆分器
  - isParallel
```
default boolean isParallel()
```
    返回流的并行状态
    
    指定者:
    
    isParallel 在接口中 BaseStream<T,Stream<T>>
    
    返回:
    
    流的并行状态
  - sequential
```
default S sequential()
```
    返回一个串行流，该方法可以将并行流转换为串行流
    
    指定者:
    
    sequential 在接口中 BaseStream<T,Stream<T>>
    
    返回:
    
    串行流
  - parallel
```
default S parallel()
```
    将流转换为并行
    
    指定者:
    
    parallel 在接口中 BaseStream<T,Stream<T>>
    
    返回:
    
    并行流
  - unordered
```
default S unordered()
```
    返回一个无序流(无手动排序)
    标记一个流是不在意元素顺序的, 在并行流的某些情况下可以提高性能
    
    指定者:
    
    unordered 在接口中 BaseStream<T,Stream<T>>
    
    返回:
    
    无序流
  - onClose
```
default S onClose(Runnable closeHandler)
```
    在流关闭时执行操作
    
    指定者:
    
    onClose 在接口中 BaseStream<T,Stream<T>>
    
    参数:
    
    closeHandler - 在流关闭时执行的操作
    
    返回:
    
    流
  - close
```
default void close()
```
    关闭流
    
    指定者:
    
    close 在接口中 AutoCloseable
    
    指定者:
    
    close 在接口中 BaseStream<T,Stream<T>>
    
    另请参阅:
    
    AutoCloseable.close()
  - hashCode
```
int hashCode()
```
    获取当前实例的哈希值
    
    覆盖:
    
    hashCode 在类中 Object
    
    返回:
    
    哈希值
  - equals
```
boolean equals(Object obj)
```
    比较实例是否相等
    
    覆盖:
    
    equals 在类中 Object
    
    参数:
    
    obj - 对象
    
    返回:
    
    是否相等
  - toString
```
String toString()
```
    将当前实例转为字符串
    
    覆盖:
    
    toString 在类中 Object
    
    返回:
    
    字符串
  - easyStream
```
default EasyStream<T> easyStream()
```
    转换为EasyStream
    
    返回:
    
    转换后的EasyStream

接口 WrappedStream<T,S extends WrappedStream<T,S>>

嵌套类概要

从接口继承的嵌套类/接口 java.util.stream.Stream

字段概要

方法概要

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

字段详细资料

NOT_FOUND_ELEMENT_INDEX

方法详细资料

unwrap

wrap

filter

mapToInt

mapToLong

mapToDouble

flatMapToInt

flatMapToLong

flatMapToDouble

distinct

sorted

sorted

peek

limit

skip

forEach

forEachOrdered

toArray

toArray

reduce

reduce

reduce

collect

collect

min

max

count

anyMatch

allMatch

noneMatch

findFirst

findAny

iterator

spliterator

isParallel

sequential

parallel

unordered

onClose

close

hashCode

equals

toString

easyStream