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

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

All Known Implementing Classes:: EasyStream, EnhancedWrappedStream, EntryStream

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

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

Since:: Java 17+
Author:: Kimi Liu

Nested Class Summary

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

Fields inherited from interface org.miaixz.bus.core.center.stream.WrappedStream
NOT_FOUND_ELEMENT_INDEX
Method Summary

Modifier and Type

Method

Description

default S

append(Iterable<? extends T> iterable)

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

default <F> EasyStream<T>

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

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

default S

dropWhile(Predicate<? super T> predicate)

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

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组合在一起，形成一个新的流:

default <R> EasyStream<R>

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

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

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:

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 的新元素组成的流这是一个无状态中间操作

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)

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

default EasyStream<EasyStream<T>>

split(int batchSize)

按指定长度切分为双层流

default EasyStream<List<T>>

splitList(int batchSize)

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

default S

takeWhile(Predicate<? super T> predicate)

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

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 转换为新的元素，并返回新元素组成的流新流的数量为两个集合中较小的数量, 即, 只合并下标位置相同的部分

Methods inherited from interface java.util.stream.Stream
mapMultiToDouble, mapMultiToInt, mapMultiToLong, toList

Methods inherited from interface org.miaixz.bus.core.center.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

Method Details
- zip
  
  default <U, R> EasyStream<R> zip(Iterable<U> other, BiFunction<? super T,? super U,? extends R> zipper)
  
  将现有元素与给定迭代器中对应位置的元素使用 zipper 转换为新的元素，并返回新元素组成的流新流的数量为两个集合中较小的数量, 即, 只合并下标位置相同的部分
  
  Type Parameters:
  
  U - 给定的迭代对象类型
  
  R - 合并后的结果对象类型
  
  Parameters:
  
  other - 给定的迭代器
  
  zipper - 两个元素的合并器
  
  Returns:
  
  合并后的结果对象的流
- split
  
  default EasyStream<EasyStream<T>> split(int batchSize)
  
  按指定长度切分为双层流
  形如：[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
  
  Parameters:
  
  batchSize - 指定长度, 正整数
  
  Returns:
  
  切好的流
- splitList
  
  default EasyStream<List<T>> splitList(int batchSize)
  
  按指定长度切分为元素为list的流
  形如：[1,2,3,4,5] -> [[1,2], [3,4], [5,6]]
  
  Parameters:
  
  batchSize - 指定长度, 正整数
  
  Returns:
  
  切好的流
- toEntries
  
  default <K, V> EntryStream<K,V> toEntries(Function<T,K> keyMapper, Function<T,V> valueMapper)
  
  将当前流转为键值对流
  
  Type Parameters:
  
  K - 键类型
  
  V - 值类型
  
  Parameters:
  
  keyMapper - 键的映射方法
  
  valueMapper - 值的映射方法
  
  Returns:
  
  EntryStream实例
- toEntries
  
  default <K> EntryStream<K,T> toEntries(Function<T,K> keyMapper)
  
  将当前流转为键值对流
  
  Type Parameters:
  
  K - 键类型
  
  Parameters:
  
  keyMapper - 键的映射方法
  
  Returns:
  
  EntryStream实例
- reverse
  
  default S reverse()
  
  反转顺序
  
  Returns:
  
  反转元素顺序
- parallel
  
  default S parallel(boolean parallel)
  
  更改流的并行状态
  
  Parameters:
  
  parallel - 是否并行
  
  Returns:
  
  流
- splice
  
  default S splice(int start, int deleteCount, T... items)
  
  通过删除或替换现有元素或者原地添加新的元素来修改列表，并以列表形式返回被修改的内容。此方法不会改变原列表。类似js的splice函数
  
  Parameters:
  
  start - 起始下标
  
  deleteCount - 删除个数，正整数
  
  items - 放入值
  
  Returns:
  
  操作后的流
- 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();
  若非必要，不推荐在并行流中进行该操作。
  Specified by:
  
  takeWhile in interface Stream<T>
  
  Parameters:
  
  predicate - 断言
  
  Returns:
  
  与指定断言匹配的元素组成的流
- 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();
  若非必要，不推荐在并行流中进行该操作。
  Specified by:
  
  dropWhile in interface Stream<T>
  
  Parameters:
  
  predicate - 断言
  
  Returns:
  
  剩余元素组成的流
- distinct
  
  default <F> EasyStream<T> distinct(Function<? super T,F> keyExtractor)
  
  返回一个具有去重特征的流非并行流(顺序流)下对于重复元素，保留遇到顺序中最先出现的元素，并行流情况下不能保证具体保留哪一个这是一个有状态中间操作
  
  Type Parameters:
  
  F - 参数类型
  
  Parameters:
  
  keyExtractor - 去重依据
  
  Returns:
  
  一个具有去重特征的流
- peekIdx
  
  default S peekIdx(BiConsumer<? super T,Integer> action)
  返回与指定函数将元素作为参数执行后组成的流。操作带下标
  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());
  Parameters:
  
  action - 指定的函数
  
  Returns:
  
  返回叠加操作后的FastStream当你需要查看经过操作管道某处的元素和下标，可以执行以下操作:
- log
  
  default S log()
  
  返回叠加调用Console.log(Object)打印出结果的流
  
  Returns:
  
  返回叠加操作后的FastStream
- push
  
  default S push(T... obj)
  
  与给定元素组成的流合并，成为新的流
  
  Parameters:
  
  obj - 元素
  
  Returns:
  
  流
- unshift
  
  default S unshift(T... obj)
  
  给定元素组成的流与当前流合并，成为新的流
  
  Parameters:
  
  obj - 元素
  
  Returns:
  
  流
- append
  
  default S append(Iterable<? extends T> iterable)
  
  将输入元素转为流，返回一个前半段为当前流，后半段为新流的新实例
  
  Parameters:
  
  iterable - 集合
  
  Returns:
  
  EntryStream实例
- prepend
  
  default S prepend(Iterable<? extends T> iterable)
  
  将输入元素转为流，返回一个前半段为新流，后半段为当前流的新实例
  
  Parameters:
  
  iterable - 集合
  
  Returns:
  
  EntryStream实例
- nonNull
  
  default S nonNull()
  
  过滤掉空元素
  
  Returns:
  
  过滤后的流
- filterIdx
  
  default S filterIdx(BiPredicate<? super T,Integer> predicate)
  
  过滤元素，返回与指定断言匹配的元素组成的流，断言带下标
  
  Parameters:
  
  predicate - 断言
  
  Returns:
  
  返回叠加过滤操作后的流
- filter
  
  default <R> S filter(Function<? super T,? extends R> mapper, R value)
  
  过滤元素，返回与指定操作结果匹配指定值的元素组成的流这是一个无状态中间操作
  
  Type Parameters:
  
  R - 返回类型
  
  Parameters:
  
  mapper - 操作
  
  value - 用来匹配的值
  
  Returns:
  
  与指定操作结果匹配指定值的元素组成的流
- 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()));
  Specified by:
  
  flatMap in interface Stream<T>
  
  Type Parameters:
  
  R - 拆分后流的元素类型
  
  Parameters:
  
  mapper - 操作，返回流
  
  Returns:
  
  返回叠加拆分操作后的流
- flatMapIdx
  
  default <R> EasyStream<R> flatMapIdx(BiFunction<? super T,Integer,? extends Stream<? extends R>> mapper)
  
  扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流，操作带下标
  
  Type Parameters:
  
  R - 拆分后流的元素类型
  
  Parameters:
  
  mapper - 操作，返回流
  
  Returns:
  
  返回叠加拆分操作后的流
- 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()));
  Type Parameters:
  
  R - 拆分后流的元素类型
  
  Parameters:
  
  mapper - 操作，返回可迭代对象
  
  Returns:
  
  返回叠加拆分操作后的流
- flatNonNull
  
  default <R> EasyStream<R> flatNonNull(Function<? super T,? extends Iterable<? extends R>> mapper)
  
  扩散流操作，可能影响流元素个数，对过滤后的非null元素执行mapper操作，转换为迭代器, 并过滤迭代器中为null的元素, 返回所有迭代器的所有非空元素组成的流这是一个无状态中间操作
  Type Parameters:
  
  R - 拆分后流的元素类型
  
  Parameters:
  
  mapper - 操作，返回流
  
  Returns:
  
  返回叠加拆分操作后的流
  
  See Also:
  
  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();
  Parameters:
  
  childrenGetter - 获取子节点的lambda，可以写作 Student::getChildren
  
  childrenSetter - 设置子节点的lambda，可以写作 Student::setChildren
  
  Returns:
  
  EasyStream 一个流
- flat
  
  default <R> EasyStream<R> flat()
  
  如果当前元素是集合，则会将集合中的元素解构出来例如：List<List<List<String>>> 解构成 List<String>
  
  Type Parameters:
  
  R - 函数执行后返回的List里面的类型
  
  Returns:
  
  EasyStream 一个流
- map
  
  default <R> EasyStream<R> map(Function<? super T,? extends R> mapper)
  
  返回与指定函数将元素作为参数执行的结果组成的流这是一个无状态中间操作
  
  Specified by:
  
  map in interface Stream<T>
  
  Type Parameters:
  
  R - 函数执行后返回的类型
  
  Parameters:
  
  mapper - 指定的函数
  
  Returns:
  
  返回叠加操作后的流
- mapNonNull
  
  default <R> EasyStream<R> mapNonNull(Function<? super T,? extends R> mapper)
  返回元素转换后并且不为 null 的新元素组成的流这是一个无状态中间操作
  // 等价于先调用map再调用nonNull .nonNull().map(...).nonNull()...
  Type Parameters:
  
  R - 函数执行后返回的类型
  
  Parameters:
  
  mapper - 指定的函数
  
  Returns:
  
  新元素组成的流
- mapIdx
  
  default <R> EasyStream<R> mapIdx(BiFunction<? super T,Integer,? extends R> mapper)
  
  返回与指定函数将元素作为参数执行的结果组成的流，操作带下标
  
  Type Parameters:
  
  R - 函数执行后返回的类型
  
  Parameters:
  
  mapper - 指定的函数
  
  Returns:
  
  返回叠加操作后的流
- mapMulti
  
  default <R> EasyStream<R> mapMulti(BiConsumer<? super T,? super Consumer<R>> mapper)
  
  扩散流操作，可能影响流元素个数，将原有流元素执行mapper操作，返回多个流所有元素组成的流，操作带一个方法，调用该方法可增加元素这是一个无状态中间操作
  
  Specified by:
  
  mapMulti in interface Stream<T>
  
  Type Parameters:
  
  R - 拆分后流的元素类型
  
  Parameters:
  
  mapper - 操作，返回流
  
  Returns:
  
  返回叠加拆分操作后的流

Interface TransformableWrappedStream<T,S extends TransformableWrappedStream<T,S>>

Nested Class Summary

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

Field Summary

Fields inherited from interface org.miaixz.bus.core.center.stream.WrappedStream

Method Summary

Methods inherited from interface java.util.stream.Stream

Methods inherited from interface org.miaixz.bus.core.center.stream.WrappedStream

Method Details

zip

split

splitList

toEntries

toEntries

reverse

parallel

splice

takeWhile

dropWhile

distinct

peekIdx

log

push

unshift

append

prepend

nonNull

filterIdx

filter

flatMap

flatMapIdx

flat

flatNonNull

flatTree

flat

map

mapNonNull

mapIdx

mapMulti