Package org.miaixz.bus.core.center.stream

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

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:

• TerminableWrappedStream
• TransformableWrappedStream
• EnhancedWrappedStream
• EasyStream
• EntryStream

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 object)	比较实例是否相等
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, gather, 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 object)

比较实例是否相等

Overrides:

equals in class Object

Parameters:

object - 对象

Returns:

是否相等

toString

String toString()

将当前实例转为字符串

Overrides:

toString in class Object

Returns:

字符串

easyStream

default EasyStream<T> easyStream()

转换为EasyStream

Returns:

转换后的EasyStream