StreamUtil (hutool 6.0.0-M20 API)

java.lang.Object
- org.dromara.hutool.core.stream.StreamUtil

```
public class StreamUtil
extends Object
```
Stream 工具类

Since:

5.6.7

Author:

looly emptypoint VampireAchao

Constructor Summary

Constructors
Constructor and Description

StreamUtil()

Constructors
Constructor and Description
`StreamUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> Stream<T>`	`dropWhile(Stream<T> source, Predicate<? super T> predicate)` 删除与指定断言匹配的元素, 在第一次不匹配时终止, 返回当前(第一个不匹配元素)及剩余元素组成的新流与 jdk9 中的 dropWhile 方法不太一样, 这里的实现是个顺序的、有状态的中间操作本环节中是顺序执行的, 但是后续操作可以支持并行流但是不建议在并行流中使用, 除非你确定 dropWhile 之后的操作能在并行流中受益很多
`static <T> Stream<T>`	`iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)` 返回无限有序流该流由初始值然后判断条件以及执行迭代函数进行迭代获取到元素
`static <T> Stream<T>`	`iterateHierarchies(T root, Function<T,Collection<T>> discoverer)` 指定一个层级结构的根节点（通常是树或图），然后获取包含根节点在内，根节点所有层级结构中的节点组成的流。
`static <T> Stream<T>`	`iterateHierarchies(T root, Function<T,Collection<T>> discoverer, Predicate<T> filter)` 指定一个层级结构的根节点（通常是树或图），然后获取包含根节点在内，根节点所有层级结构中的节点组成的流。
`static <T> String`	`join(Stream<T> stream, CharSequence delimiter)` 将Stream中所有元素以指定分隔符，合并为一个字符串，对象默认调用toString方法
`static <T> String`	`join(Stream<T> stream, CharSequence delimiter, Function<T,? extends CharSequence> toStringFunc)` 将Stream中所有元素以指定分隔符，合并为一个字符串
`static Stream<String>`	`of(File file)` 按行读取文件为`Stream`
`static Stream<String>`	`of(File file, Charset charset)` 按行读取文件为`Stream`
`static <T> Stream<T>`	`of(Iterable<T> iterable)` `Iterable`转换为`Stream`，默认非并行
`static <T> Stream<T>`	`of(Iterable<T> iterable, boolean parallel)` `Iterable`转换为`Stream`
`static Stream<String>`	`of(Path path)` 按行读取文件为`Stream`
`static Stream<String>`	`of(Path path, Charset charset)` 按行读取文件为`Stream`
`static <T> Stream<T>`	`of(T... array)`
`static <T> Stream<T>`	`of(T seed, UnaryOperator<T> elementCreator, int limit)` 通过函数创建Stream
`static <T> Stream<T>`	`ofIter(Iterator<T> iterator)` `Iterator` 转换为 `Stream`
`static <T> Stream<T>`	`ofIter(Iterator<T> iterator, boolean parallel)` `Iterator` 转换为 `Stream`
`static <T> Stream<T>`	`takeWhile(Stream<T> source, Predicate<? super T> predicate)` 保留与指定断言匹配时的元素, 在第一次不匹配时终止, 抛弃当前(第一个不匹配元素)及后续所有元素与 jdk9 中的 takeWhile 方法不太一样, 这里的实现是个顺序的、有状态的中间操作本环节中是顺序执行的, 但是后续操作可以支持并行流但是不建议在并行流中使用, 除非你确定 takeWhile 之后的操作能在并行流中受益很多

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - StreamUtil
```
public StreamUtil()
```
- Method Detail
  - of
```
@SafeVarargs
public static <T> Stream<T> of(T... array)
```
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    Stream，如果提供的array为null，返回Stream.empty()
  - of
```
public static <T> Stream<T> of(Iterable<T> iterable)
```
    Iterable转换为Stream，默认非并行
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterable - 集合
    
    Returns:
    
    Stream，如果提供的iterator为null，返回Stream.empty()
  - of
```
public static <T> Stream<T> of(Iterable<T> iterable,
                               boolean parallel)
```
    Iterable转换为Stream
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterable - 集合
    
    parallel - 是否并行
    
    Returns:
    
    Stream，如果提供的iterator为null，返回Stream.empty()
  - ofIter
```
public static <T> Stream<T> ofIter(Iterator<T> iterator)
```
    Iterator 转换为 Stream
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterator - 迭代器
    
    Returns:
    
    Stream，如果提供的iterator为null，返回Stream.empty()
  - ofIter
```
public static <T> Stream<T> ofIter(Iterator<T> iterator,
                                   boolean parallel)
```
    Iterator 转换为 Stream
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterator - 迭代器
    
    parallel - 是否并行
    
    Returns:
    
    Stream，如果提供的iterator为null，返回Stream.empty()
  - of
```
public static Stream<String> of(File file)
```
    按行读取文件为Stream
    
    Parameters:
    
    file - 文件
    
    Returns:
    
    Stream，如果提供的file为null，返回Stream.empty()
  - of
```
public static Stream<String> of(Path path)
```
    按行读取文件为Stream
    
    Parameters:
    
    path - 路径
    
    Returns:
    
    Stream，如果提供的file为null，返回Stream.empty()
  - of
```
public static Stream<String> of(File file,
                                Charset charset)
```
    按行读取文件为Stream
    
    Parameters:
    
    file - 文件
    
    charset - 编码
    
    Returns:
    
    Stream，如果提供的file为null，返回Stream.empty()
  - of
```
public static Stream<String> of(Path path,
                                Charset charset)
```
    按行读取文件为Stream
    
    Parameters:
    
    path - 路径
    
    charset - 编码
    
    Returns:
    
    Stream，如果提供的path为null，返回Stream.empty()
  - of
```
public static <T> Stream<T> of(T seed,
                               UnaryOperator<T> elementCreator,
                               int limit)
```
    通过函数创建Stream
    
    Type Parameters:
    
    T - 创建元素类型
    
    Parameters:
    
    seed - 初始值
    
    elementCreator - 递进函数，每次调用此函数获取下一个值
    
    limit - 限制个数
    
    Returns:
    
    Stream
  - join
```
public static <T> String join(Stream<T> stream,
                              CharSequence delimiter)
```
    将Stream中所有元素以指定分隔符，合并为一个字符串，对象默认调用toString方法
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    stream - Stream
    
    delimiter - 分隔符
    
    Returns:
    
    字符串，如果stream为null，返回null
  - join
```
public static <T> String join(Stream<T> stream,
                              CharSequence delimiter,
                              Function<T,? extends CharSequence> toStringFunc)
```
    将Stream中所有元素以指定分隔符，合并为一个字符串
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    stream - Stream
    
    delimiter - 分隔符
    
    toStringFunc - 元素转换为字符串的函数
    
    Returns:
    
    字符串，如果stream为null，返回null
  - iterate
```
public static <T> Stream<T> iterate(T seed,
                                    Predicate<? super T> hasNext,
                                    UnaryOperator<T> next)
```
    返回无限有序流该流由初始值然后判断条件以及执行迭代函数进行迭代获取到元素
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    seed - 初始值
    
    hasNext - 条件值
    
    next - 用上一个元素作为参数执行并返回一个新的元素
    
    Returns:
    
    无限有序流
  - iterateHierarchies
```
public static <T> Stream<T> iterateHierarchies(T root,
                                               Function<T,Collection<T>> discoverer,
                                               Predicate<T> filter)
```
    指定一个层级结构的根节点（通常是树或图），然后获取包含根节点在内，根节点所有层级结构中的节点组成的流。
    该方法用于以平铺的方式按广度优先对图或树节点进行访问，可以使用并行流提高效率。
    eg:
```
 Tree root = // 构建树结构
 // 搜索树结构中所有级别为3的节点，并按权重排序
 List<Tree> thirdLevelNodes = StreamUtil.iterateHierarchies(root, Tree:getChildren)
 	.filter(node -> node.getLevel() == 3)
 	.sorted(Comparator.comparing(Tree::getWeight))
 	.toList();
 
```
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    root - 根节点，根节点不允许被filter过滤
    
    discoverer - 下一层级节点的获取方法
    
    filter - 节点过滤器，不匹配的节点与以其作为根节点的子树将将会被忽略
    
    Returns:
    
    包含根节点在内，根节点所有层级结构中的节点组成的流
    
    See Also:
    
    HierarchyIterator
  - iterateHierarchies
```
public static <T> Stream<T> iterateHierarchies(T root,
                                               Function<T,Collection<T>> discoverer)
```
    指定一个层级结构的根节点（通常是树或图），然后获取包含根节点在内，根节点所有层级结构中的节点组成的流。
    该方法用于以平铺的方式按广度优先对图或树节点进行访问，可以使用并行流提高效率。
    eg:
```
 Tree root = // 构建树结构
 // 搜索树结构中所有级别为3的节点，并按权重排序
 List<Tree> thirdLevelNodes = StreamUtil.iterateHierarchies(root, Tree:getChildren)
 	.filter(node -> node.getLevel() == 3)
 	.sorted(Comparator.comparing(Tree::getWeight))
 	.toList();
 
```
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    root - 根节点，根节点不允许被filter过滤
    
    discoverer - 下一层级节点的获取方法
    
    Returns:
    
    包含根节点在内，根节点所有层级结构中的节点组成的流
    
    See Also:
    
    HierarchyIterator
  - takeWhile
```
public static <T> Stream<T> takeWhile(Stream<T> source,
                                      Predicate<? super T> predicate)
```
    保留与指定断言匹配时的元素, 在第一次不匹配时终止, 抛弃当前(第一个不匹配元素)及后续所有元素
    与 jdk9 中的 takeWhile 方法不太一样, 这里的实现是个顺序的、有状态的中间操作
    
    本环节中是顺序执行的, 但是后续操作可以支持并行流
    
    但是不建议在并行流中使用, 除非你确定 takeWhile 之后的操作能在并行流中受益很多
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    source - 源流
    
    predicate - 断言
    
    Returns:
    
    与指定断言匹配的元素组成的流
  - dropWhile
```
public static <T> Stream<T> dropWhile(Stream<T> source,
                                      Predicate<? super T> predicate)
```
    删除与指定断言匹配的元素, 在第一次不匹配时终止, 返回当前(第一个不匹配元素)及剩余元素组成的新流
    与 jdk9 中的 dropWhile 方法不太一样, 这里的实现是个顺序的、有状态的中间操作
    
    本环节中是顺序执行的, 但是后续操作可以支持并行流
    
    但是不建议在并行流中使用, 除非你确定 dropWhile 之后的操作能在并行流中受益很多
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    source - 源流
    
    predicate - 断言
    
    Returns:
    
    剩余元素组成的流

Class StreamUtil

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

StreamUtil

Method Detail

of

of

of

ofIter

ofIter

of

of

of

of

of

join

join

iterate

iterateHierarchies

iterateHierarchies

takeWhile

dropWhile