Type Parameters:: T - 流中的元素类型; S - WrappedStream的实现类类型

All Superinterfaces:: AutoCloseable, BaseStream<T,Stream<T>>, Iterable<T>, Stream<T>

All Known Subinterfaces:: TerminableWrappedStream<T,S>, TransformableWrappedStream<T,S>

All Known Implementing Classes:: EasyStream, EnhancedWrappedStream, EntryStream

public interface WrappedStream<T,S extends WrappedStream<T,S>> extends Stream<T>, Iterable<T>

Stream实例的包装器，用于增强原始的Stream，提供一些额外的中间与终端操作。默认提供两个可用实现：

EasyStream：针对单元素的通用增强流实现；
EntryStream：针对键值对类型元素的增强流实现；

Since:

Java 17+

Author:

Kimi Liu

See Also:

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.stream.Stream
Stream.Builder<T>
Field Summary

Fields

Modifier and Type

Field

Description

static final int

NOT_FOUND_ELEMENT_INDEX

代表不存在的下标, 或者未找到元素时的下标
Method Summary

Modifier and Type

Method

Description

default boolean

allMatch(Predicate<? super T> predicate)

判断是否所有元素满足给定断言

default boolean

anyMatch(Predicate<? super T> predicate)

判断是否有任何一个元素满足给定断言

default void

close()

关闭流

default <R> R

collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)

对元素进行收集，并返回收集后的容器这是一个终端操作

default <R, A> R

collect(Collector<? super T,A,R> collector)

对元素进行收集，并返回收集后的元素这是一个终端操作

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] 该操作相当于：

default T

reduce(T identity, BinaryOperator<T> accumulator)

对元素进行聚合，并返回聚合后的值，相当于在for循环里写sum=sum+ints[i] 这是一个终端操作求和、最小值、最大值、平均值和转换成一个String字符串均为聚合操作例如这里对int进行求和可以写成：

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

String

toString()

将当前实例转为字符串

default S

unordered()

返回一个无序流(无手动排序)

Stream<T>

unwrap()

获取被当前实例包装的流对象

S

wrap(Stream<T> source)

将一个原始流包装为指定类型的增强流若source于当前实例包装的流并不相同，则该增强流与当前实例无关联关系

Methods inherited from interface java.util.stream.Stream
dropWhile, flatMap, map, mapMulti, mapMultiToDouble, mapMultiToInt, mapMultiToLong, takeWhile, toList

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

Interface WrappedStream<T,S extends WrappedStream<T,S>>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.stream.Stream

Field Summary

Method Summary

Methods inherited from interface java.util.stream.Stream

Field Details

NOT_FOUND_ELEMENT_INDEX

Method Details

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