org.dromara.hutool.core.stream

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

类型参数:

T - 流中的元素类型

S - TransformableWrappedStream的实现类类型

所有超级接口:

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

所有已知实现类:

AbstractEnhancedWrappedStream, EasyStream, EntryStream

public interface TransformableWrappedStream<T,S extends TransformableWrappedStream<T,S>>
extends WrappedStream<T,S>

WrappedStream的扩展，用于为实现类提供更多中间操作方法的增强接口， 该接口提供的方法，返回值类型都为Stream。

作者:

huangchengxing VampireAchao

从以下版本开始:

6.0.0

嵌套类概要

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

Stream.Builder<T>

字段概要

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

NOT_FOUND_ELEMENT_INDEX

方法概要

限定符和类型	方法和说明
default S	append(Iterable<? extends T> iterable) 将输入元素转为流，返回一个前半段为当前流，后半段为新流的新实例
default <F> EasyStream<T>	distinct(Function<? super T,F> keyExtractor) 返回一个具有去重特征的流 非并行流(顺序流)下对于重复元素，保留遇到顺序中最先出现的元素，并行流情况下不能保证具体保留哪一个 这是一个有状态中间操作
default S	dropWhile(Predicate<? super T> predicate) 删除流中与断言匹配的元素，当遇到第一个不匹配的元素时终止，返回由剩余不匹配的元素组成的流。
default <R> S	filter(Function<? super T,? extends R> mapper, R value) 过滤元素，返回与 指定操作结果 匹配 指定值 的元素组成的流 这是一个无状态中间操作
default S	filterIdx(BiPredicate<? super T,Integer> predicate) 过滤元素，返回与指定断言匹配的元素组成的流，断言带下标
default <R> EasyStream<R>	flat() 如果当前元素是集合，则会将集合中的元素解构出来 例如：List<List<List<String>>> 解构成 List<String>
default <R> EasyStream<R>	flat(Function<? super T,? extends Iterable<? extends R>> mapper) 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作, 转换为迭代器元素, 最后返回所有迭代器的所有元素组成的流 这是一个无状态中间操作 例如，将users里所有user的id和parentId组合在一起，形成一个新的流: EasyStream<Long> ids = EasyStream.of(users).flat(user -> FastStream.of(user.getId(), user.getParentId()));
default <R> EasyStream<R>	flatMap(Function<? super T,? extends Stream<? extends R>> mapper) 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流 这是一个无状态中间操作 例如，将users里所有user的id和parentId组合在一起，形成一个新的流: EasyStream<Long> ids = EasyStream.of(users).flatMap(user -> FastStream.of(user.getId(), user.getParentId()));
default <R> EasyStream<R>	flatMapIdx(BiFunction<? super T,Integer,? extends Stream<? extends R>> mapper) 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流，操作带下标
default <R> EasyStream<R>	flatNonNull(Function<? super T,? extends Iterable<? extends R>> mapper) 扩散流操作，可能影响流元素个数，对过滤后的非null元素执行mapper操作，转换为迭代器, 并过滤迭代器中为null的元素, 返回所有迭代器的所有非空元素组成的流 这是一个无状态中间操作
default S	flatTree(Function<T,List<T>> childrenGetter, BiConsumer<T,List<T>> childrenSetter) 将树递归扁平化为集合，内置一个小递归 这是一个无状态中间操作 eg: List<Student> students = EasyStream.of(studentTree) .flatTree(Student::getChildren, Student::setChildren) .toList();
default S	log() 返回叠加调用Console.log(Object)打印出结果的流
default <R> EasyStream<R>	map(Function<? super T,? extends R> mapper) 返回与指定函数将元素作为参数执行的结果组成的流 这是一个无状态中间操作
default <R> EasyStream<R>	mapIdx(BiFunction<? super T,Integer,? extends R> mapper) 返回与指定函数将元素作为参数执行的结果组成的流，操作带下标
default <R> EasyStream<R>	mapMulti(BiConsumer<? super T,? super Consumer<R>> mapper) 扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流，操作带一个方法，调用该方法可增加元素 这是一个无状态中间操作
default <R> EasyStream<R>	mapNonNull(Function<? super T,? extends R> mapper) 返回 元素 转换后 并且不为 null 的 新元素组成的流 这是一个无状态中间操作 // 等价于先调用map再调用nonNull .nonNull().map(...).nonNull()...
default S	nonNull() 过滤掉空元素
default S	parallel(boolean parallel) 更改流的并行状态
default S	peekIdx(BiConsumer<? super T,Integer> action) 返回与指定函数将元素作为参数执行后组成的流。
default S	prepend(Iterable<? extends T> iterable) 将输入元素转为流，返回一个前半段为新流，后半段为当前流的新实例
default S	push(T... obj) 与给定元素组成的流合并，成为新的流
default S	reverse() 反转顺序
default S	splice(int start, int deleteCount, T... items) 通过删除或替换现有元素或者原地添加新的元素来修改列表，并以列表形式返回被修改的内容。
default EasyStream<EasyStream<T>>	split(int batchSize) 按指定长度切分为双层流 形如：[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
default EasyStream<List<T>>	splitList(int batchSize) 按指定长度切分为元素为list的流 形如：[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
default S	takeWhile(Predicate<? super T> predicate) 遍历流中与断言匹配的元素，当遇到第一个不匹配的元素时终止，返回由匹配的元素组成的流。
default <K> EntryStream<K,T>	toEntries(Function<T,K> keyMapper) 将当前流转为键值对流
default <K,V> EntryStream<K,V>	toEntries(Function<T,K> keyMapper, Function<T,V> valueMapper) 将当前流转为键值对流
default S	unshift(T... obj) 给定元素组成的流与当前流合并，成为新的流
default <U,R> EasyStream<R>	zip(Iterable<U> other, BiFunction<? super T,? super U,? extends R> zipper) 将 现有元素 与 给定迭代器中对应位置的元素 使用 zipper 转换为新的元素，并返回新元素组成的流 新流的数量为两个集合中较小的数量, 即, 只合并下标位置相同的部分

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

allMatch, anyMatch, close, collect, collect, count, distinct, easyStream, equals, filter, findAny, findFirst, flatMapToDouble, flatMapToInt, flatMapToLong, forEach, forEachOrdered, hashCode, isParallel, iterator, limit, mapToDouble, mapToInt, mapToLong, max, min, noneMatch, onClose, parallel, peek, reduce, reduce, reduce, sequential, skip, sorted, sorted, spliterator, toArray, toArray, toString, unordered, unwrap, wrap

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

builder, concat, empty, generate, iterate, of, of

方法详细资料

zip

default <U,R> EasyStream<R> zip(Iterable<U> other,
                                BiFunction<? super T,? super U,? extends R> zipper)

将 现有元素 与 给定迭代器中对应位置的元素 使用 zipper 转换为新的元素，并返回新元素组成的流
新流的数量为两个集合中较小的数量, 即, 只合并下标位置相同的部分

类型参数:

U - 给定的迭代对象类型

R - 合并后的结果对象类型

参数:

other - 给定的迭代器

zipper - 两个元素的合并器

返回:

合并后的结果对象的流

split

default EasyStream<EasyStream<T>> split(int batchSize)

按指定长度切分为双层流

形如：[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]

参数:

batchSize - 指定长度, 正整数

返回:

切好的流

splitList

default EasyStream<List<T>> splitList(int batchSize)

按指定长度切分为元素为list的流

形如：[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]

参数:

batchSize - 指定长度, 正整数

返回:

切好的流

toEntries

default <K,V> EntryStream<K,V> toEntries(Function<T,K> keyMapper,
                                         Function<T,V> valueMapper)

将当前流转为键值对流

类型参数:

K - 键类型

V - 值类型

参数:

keyMapper - 键的映射方法

valueMapper - 值的映射方法

返回:

EntryStream实例

toEntries

default <K> EntryStream<K,T> toEntries(Function<T,K> keyMapper)

将当前流转为键值对流

类型参数:

K - 键类型

参数:

keyMapper - 键的映射方法

返回:

EntryStream实例

reverse

default S reverse()

反转顺序

返回:

反转元素顺序

parallel

default S parallel(boolean parallel)

更改流的并行状态

参数:

parallel - 是否并行

返回:

流

splice

default S splice(int start,
                 int deleteCount,
                 T... items)

通过删除或替换现有元素或者原地添加新的元素来修改列表，并以列表形式返回被修改的内容。此方法不会改变原列表。 类似js的splice函数

参数:

start - 起始下标

deleteCount - 删除个数，正整数

items - 放入值

返回:

操作后的流

takeWhile

default S takeWhile(Predicate<? super T> predicate)

遍历流中与断言匹配的元素，当遇到第一个不匹配的元素时终止，返回由匹配的元素组成的流。
eg:

 EasyStream.of(1, 2, 3, 4, 5)
 	.takeWhile(i -> Objects.equals(3, i)) // 获取元素，一直到遇到第一个3为止
 	.toList(); // = [1, 2]
 

与JDK9中的takeWhile方法不太一样，此操作为顺序且有状态的中间操作。 即使在并行流中，该操作仍然是顺序执行的，并且不影响后续的并行操作：

 EasyStream.iterate(1, i -> i + 1)
 	.parallel()
 	.takeWhile(e -> e < 50) // 顺序执行
 	.map(e -> e + 1) // 并发
 	.map(String::valueOf) // 并发
 	.toList();
 

若非必要，不推荐在并行流中进行该操作。

参数:

predicate - 断言

返回:

与指定断言匹配的元素组成的流

dropWhile

default S dropWhile(Predicate<? super T> predicate)

删除流中与断言匹配的元素，当遇到第一个不匹配的元素时终止，返回由剩余不匹配的元素组成的流。
eg:

 EasyStream.of(1, 2, 3, 4, 5)
 	.dropWhile(i -> !Objects.equals(3, i)) // 删除不为3的元素，一直到遇到第一个3为止
 	.toList(); // = [3, 4, 5]
 

与JDK9中的dropWhile方法不太一样，此操作为顺序且有状态的中间操作。 即使在并行流中，该操作仍然是顺序执行的，并且不影响后续的并行操作：

 EasyStream.iterate(1, i -> i + 1)
 	.parallel()
 	.dropWhile(e -> e < 50) // 顺序执行
 	.map(e -> e + 1) // 并发
 	.map(String::valueOf) // 并发
 	.toList();
 

若非必要，不推荐在并行流中进行该操作。

参数:

predicate - 断言

返回:

剩余元素组成的流

distinct

default <F> EasyStream<T> distinct(Function<? super T,F> keyExtractor)

返回一个具有去重特征的流 非并行流(顺序流)下对于重复元素，保留遇到顺序中最先出现的元素，并行流情况下不能保证具体保留哪一个 这是一个有状态中间操作

类型参数:

F - 参数类型

参数:

keyExtractor - 去重依据

返回:

一个具有去重特征的流

peekIdx

default S peekIdx(BiConsumer<? super T,Integer> action)

返回与指定函数将元素作为参数执行后组成的流。操作带下标

API Note:

该方法存在的意义主要是用来调试 当你需要查看经过操作管道某处的元素和下标，可以执行以下操作:

     Stream.of("one", "two", "three", "four")
 				.filter(e -> e.length() > 3)
 				.peekIdx((e,i) -> System.out.println("Filtered value: " + e + " Filtered idx:" + i))
 				.map(String::toUpperCase)
 				.peekIdx((e,i) -> System.out.println("Mapped value: " + e + " Mapped idx:" + i))
 				.collect(Collectors.toList());
 

参数:

action - 指定的函数

返回:

返回叠加操作后的FastStream

log

default S log()

返回叠加调用Console.log(Object)打印出结果的流

返回:

返回叠加操作后的FastStream

push

default S push(T... obj)

与给定元素组成的流合并，成为新的流

参数:

obj - 元素

返回:

流

unshift

default S unshift(T... obj)

给定元素组成的流与当前流合并，成为新的流

参数:

obj - 元素

返回:

流

append

default S append(Iterable<? extends T> iterable)

将输入元素转为流，返回一个前半段为当前流，后半段为新流的新实例

参数:

iterable - 集合

返回:

EntryStream实例

prepend

default S prepend(Iterable<? extends T> iterable)

将输入元素转为流，返回一个前半段为新流，后半段为当前流的新实例

参数:

iterable - 集合

返回:

EntryStream实例

nonNull

default S nonNull()

过滤掉空元素

返回:

过滤后的流

filterIdx

default S filterIdx(BiPredicate<? super T,Integer> predicate)

过滤元素，返回与指定断言匹配的元素组成的流，断言带下标

参数:

predicate - 断言

返回:

返回叠加过滤操作后的流

filter

default <R> S filter(Function<? super T,? extends R> mapper,
                     R value)

过滤元素，返回与 指定操作结果 匹配 指定值 的元素组成的流 这是一个无状态中间操作

类型参数:

R - 返回类型

参数:

mapper - 操作

value - 用来匹配的值

返回:

与 指定操作结果 匹配 指定值 的元素组成的流

flatMap

default <R> EasyStream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)

扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流
这是一个无状态中间操作
例如，将users里所有user的id和parentId组合在一起，形成一个新的流:

     EasyStream<Long> ids = EasyStream.of(users).flatMap(user -> FastStream.of(user.getId(), user.getParentId()));
 

指定者:

flatMap 在接口中 Stream<T>

类型参数:

R - 拆分后流的元素类型

参数:

mapper - 操作，返回流

返回:

返回叠加拆分操作后的流

flatMapIdx

default <R> EasyStream<R> flatMapIdx(BiFunction<? super T,Integer,? extends Stream<? extends R>> mapper)

扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流，操作带下标

类型参数:

R - 拆分后流的元素类型

参数:

mapper - 操作，返回流

返回:

返回叠加拆分操作后的流

flat

default <R> EasyStream<R> flat(Function<? super T,? extends Iterable<? extends R>> mapper)

扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作, 转换为迭代器元素, 最后返回所有迭代器的所有元素组成的流
这是一个无状态中间操作
例如，将users里所有user的id和parentId组合在一起，形成一个新的流:

     EasyStream<Long> ids = EasyStream.of(users).flat(user -> FastStream.of(user.getId(), user.getParentId()));
 

类型参数:

R - 拆分后流的元素类型

参数:

mapper - 操作，返回可迭代对象

返回:

返回叠加拆分操作后的流

flatNonNull

default <R> EasyStream<R> flatNonNull(Function<? super T,? extends Iterable<? extends R>> mapper)

扩散流操作，可能影响流元素个数，对过滤后的非null元素执行mapper操作，转换为迭代器, 并过滤迭代器中为null的元素, 返回所有迭代器的所有非空元素组成的流
这是一个无状态中间操作

类型参数:

R - 拆分后流的元素类型

参数:

mapper - 操作，返回流

返回:

返回叠加拆分操作后的流

另请参阅:

flat(Function), nonNull()

flatTree

default S flatTree(Function<T,List<T>> childrenGetter,
                   BiConsumer<T,List<T>> childrenSetter)

将树递归扁平化为集合，内置一个小递归 这是一个无状态中间操作
eg:

 List<Student> students = EasyStream.of(studentTree)
 	.flatTree(Student::getChildren, Student::setChildren)
 	.toList();
 

参数:

childrenGetter - 获取子节点的lambda，可以写作 Student::getChildren

childrenSetter - 设置子节点的lambda，可以写作 Student::setChildren

返回:

EasyStream 一个流

flat

default <R> EasyStream<R> flat()

如果当前元素是集合，则会将集合中的元素解构出来 例如：List<List<List<String>>> 解构成 List<String>

类型参数:

R - 函数执行后返回的List里面的类型

返回:

EasyStream 一个流

从以下版本开始:

6.0.0

map

default <R> EasyStream<R> map(Function<? super T,? extends R> mapper)

返回与指定函数将元素作为参数执行的结果组成的流 这是一个无状态中间操作

指定者:

map 在接口中 Stream<T>

类型参数:

R - 函数执行后返回的类型

参数:

mapper - 指定的函数

返回:

返回叠加操作后的流

mapNonNull

default <R> EasyStream<R> mapNonNull(Function<? super T,? extends R> mapper)

返回 元素 转换后 并且不为 null 的 新元素组成的流
这是一个无状态中间操作

 // 等价于先调用map再调用nonNull
 .nonNull().map(...).nonNull()...
 

类型参数:

R - 函数执行后返回的类型

参数:

mapper - 指定的函数

返回:

新元素组成的流

mapIdx

default <R> EasyStream<R> mapIdx(BiFunction<? super T,Integer,? extends R> mapper)

返回与指定函数将元素作为参数执行的结果组成的流，操作带下标

类型参数:

R - 函数执行后返回的类型

参数:

mapper - 指定的函数

返回:

返回叠加操作后的流

mapMulti

default <R> EasyStream<R> mapMulti(BiConsumer<? super T,? super Consumer<R>> mapper)

扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流，操作带一个方法，调用该方法可增加元素 这是一个无状态中间操作

类型参数:

R - 拆分后流的元素类型

参数:

mapper - 操作，返回流

返回:

返回叠加拆分操作后的流