Streams (polaris-toolkit 3.4.6 API)

java.lang.Object
- io.polaris.core.collection.Streams

```
public class Streams
extends Object
```
流处理工具类，提供对集合、数组和Stream的各种转换和过滤操作。

从以下版本开始:

Nov 06, 2024

作者:

Qts

构造器概要

构造器
构造器和说明

Streams()

构造器
构造器和说明
`Streams()`

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static <T,U> List<U>`	`convertList(Collection<T> from, Function<T,U> func)` 将Collection中的元素进行类型转换并收集到List中，过滤掉转换后为null的元素。
`static <T,U> List<U>`	`convertList(Collection<T> from, Function<T,U> func, Predicate<T> filter)` 将Collection中的元素先进行过滤，然后进行类型转换并收集到List中，过滤掉转换后为null的元素。
`static <T,U> List<U>`	`convertList(Iterable<T> from, Function<T,U> func)` 将Iterable中的元素进行类型转换并收集到List中，过滤掉转换后为null的元素。
`static <T,U> List<U>`	`convertList(Iterable<T> from, Function<T,U> func, Predicate<T> filter)` 将Iterable中的元素先进行过滤，然后进行类型转换并收集到List中，过滤掉转换后为null的元素。
`static <T,U> List<U>`	`convertList(Stream<T> from, Function<T,U> func)` 将Stream中的元素进行类型转换并收集到List中，过滤掉转换后为null的元素。
`static <T,U> List<U>`	`convertList(Stream<T> from, Function<T,U> func, Predicate<T> filter)` 将Stream中的元素先进行过滤，然后进行类型转换并收集到List中，过滤掉转换后为null的元素。
`static <T,U> List<U>`	`convertList(T[] from, Function<T,U> func)` 将数组中的元素进行类型转换并收集到List中，过滤掉转换后为null的元素。
`static <T,U> List<U>`	`convertList(T[] from, Function<T,U> func, Predicate<T> filter)` 将数组中的元素先进行过滤，然后进行类型转换并收集到List中，过滤掉转换后为null的元素。
`static <T,U,R> List<R>`	`convertListByFlatMap(Collection<T> from, Function<? super T,? extends U> mapper, Function<U,? extends Stream<? extends R>> func)` 先将Collection中的元素进行映射，再使用flatMap展开并收集到List中，过滤掉为null的元素。
`static <T,U> List<U>`	`convertListByFlatMap(Collection<T> from, Function<T,? extends Stream<? extends U>> func)` 使用flatMap将Collection中的元素展开并收集到List中，过滤掉为null的元素。
`static <T,U,R> List<R>`	`convertListByFlatMap(Iterable<T> from, Function<? super T,? extends U> mapper, Function<U,? extends Stream<? extends R>> func)` 先将Iterable中的元素进行映射，再使用flatMap展开并收集到List中，过滤掉为null的元素。
`static <T,U> List<U>`	`convertListByFlatMap(Iterable<T> from, Function<T,? extends Stream<? extends U>> func)` 使用flatMap将Iterable中的元素展开并收集到List中，过滤掉为null的元素。
`static <T,U,R> List<R>`	`convertListByFlatMap(Stream<T> from, Function<? super T,? extends U> mapper, Function<U,? extends Stream<? extends R>> func)` 先将Stream中的元素进行映射，再使用flatMap展开并收集到List中，过滤掉为null的元素。
`static <T,U> List<U>`	`convertListByFlatMap(Stream<T> from, Function<T,? extends Stream<? extends U>> func)` 使用flatMap将Stream中的元素展开并收集到List中，过滤掉为null的元素。
`static <T,U,R> List<R>`	`convertListByFlatMap(T[] from, Function<? super T,? extends U> mapper, Function<U,? extends Stream<? extends R>> func)` 先将数组中的元素进行映射，再使用flatMap展开并收集到List中，过滤掉为null的元素。
`static <T,U> List<U>`	`convertListByFlatMap(T[] from, Function<T,? extends Stream<? extends U>> func)` 使用flatMap将数组中的元素展开并收集到List中，过滤掉为null的元素。
`static <T,K> Map<K,T>`	`convertMap(Collection<T> from, Function<T,K> keyFunc)` 将Collection中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())。
`static <T,K,V> Map<K,V>`	`convertMap(Collection<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将Collection中的元素转换为Map，使用指定的键映射函数和值映射函数。
`static <T,K,V> Map<K,V>`	`convertMap(Collection<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc, BinaryOperator<V> mergeFunction)` 将Collection中的元素转换为Map，使用指定的键映射函数、值映射函数和合并函数。
`static <T,K,V> Map<K,V>`	`convertMap(Collection<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc, BinaryOperator<V> mergeFunction, Supplier<? extends Map<K,V>> supplier)` 将Collection中的元素转换为Map，使用指定的键映射函数、值映射函数、合并函数和Map供应商。
`static <T,K,V> Map<K,V>`	`convertMap(Collection<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc, Supplier<? extends Map<K,V>> supplier)` 将Collection中的元素转换为Map，使用指定的键映射函数、值映射函数和Map供应商。
`static <T,K> Map<K,T>`	`convertMap(Collection<T> from, Function<T,K> keyFunc, Supplier<? extends Map<K,T>> supplier)` 将Collection中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())，并指定Map的实现类型。
`static <T,K> Map<K,T>`	`convertMap(Iterable<T> from, Function<T,K> keyFunc)` 将Iterable中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())。
`static <T,K,V> Map<K,V>`	`convertMap(Iterable<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将Iterable中的元素转换为Map，使用指定的键映射函数和值映射函数。
`static <T,K,V> Map<K,V>`	`convertMap(Iterable<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc, BinaryOperator<V> mergeFunction)` 将Iterable中的元素转换为Map，使用指定的键映射函数、值映射函数和合并函数。
`static <T,K,V> Map<K,V>`	`convertMap(Iterable<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc, BinaryOperator<V> mergeFunction, Supplier<? extends Map<K,V>> supplier)` 将Iterable中的元素转换为Map，使用指定的键映射函数、值映射函数、合并函数和Map供应商。
`static <T,K,V> Map<K,V>`	`convertMap(Iterable<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc, Supplier<? extends Map<K,V>> supplier)` 将Iterable中的元素转换为Map，使用指定的键映射函数、值映射函数和Map供应商。
`static <T,K> Map<K,T>`	`convertMap(Iterable<T> from, Function<T,K> keyFunc, Supplier<? extends Map<K,T>> supplier)` 将Iterable中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())，并指定Map的实现类型。
`static <T,K> Map<K,T>`	`convertMap(Stream<T> from, Function<T,K> keyFunc)` 将Stream中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())。
`static <T,K,V> Map<K,V>`	`convertMap(Stream<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将Stream中的元素转换为Map，使用指定的键映射函数和值映射函数。
`static <T,K,V> Map<K,V>`	`convertMap(Stream<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc, BinaryOperator<V> mergeFunction)` 将Stream中的元素转换为Map，使用指定的键映射函数、值映射函数和合并函数。
`static <T,K,V> Map<K,V>`	`convertMap(Stream<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc, BinaryOperator<V> mergeFunction, Supplier<? extends Map<K,V>> supplier)` 将Stream中的元素转换为Map，使用指定的键映射函数、值映射函数、合并函数和Map供应商。
`static <T,K,V> Map<K,V>`	`convertMap(Stream<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc, Supplier<? extends Map<K,V>> supplier)` 将Stream中的元素转换为Map，使用指定的键映射函数、值映射函数和Map供应商。
`static <T,K> Map<K,T>`	`convertMap(Stream<T> from, Function<T,K> keyFunc, Supplier<? extends Map<K,T>> supplier)` 将Stream中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())，并指定Map的实现类型。
`static <T,K> Map<K,T>`	`convertMap(T[] from, Function<T,K> keyFunc)` 将数组中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())。
`static <T,K,V> Map<K,V>`	`convertMap(T[] from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将数组中的元素转换为Map，使用指定的键映射函数和值映射函数。
`static <T,K,V> Map<K,V>`	`convertMap(T[] from, Function<T,K> keyFunc, Function<T,V> valueFunc, BinaryOperator<V> mergeFunction)` 将数组中的元素转换为Map，使用指定的键映射函数、值映射函数和合并函数。
`static <T,K,V> Map<K,V>`	`convertMap(T[] from, Function<T,K> keyFunc, Function<T,V> valueFunc, BinaryOperator<V> mergeFunction, Supplier<? extends Map<K,V>> supplier)` 将数组中的元素转换为Map，使用指定的键映射函数、值映射函数、合并函数和Map供应商。
`static <T,K,V> Map<K,V>`	`convertMap(T[] from, Function<T,K> keyFunc, Function<T,V> valueFunc, Supplier<? extends Map<K,V>> supplier)` 将数组中的元素转换为Map，使用指定的键映射函数、值映射函数和Map供应商。
`static <T,K> Map<K,T>`	`convertMap(T[] from, Function<T,K> keyFunc, Supplier<? extends Map<K,T>> supplier)` 将数组中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())，并指定Map的实现类型。
`static <T,K> Map<K,T>`	`convertMapByFilter(Collection<T> from, Predicate<T> filter, Function<T,K> keyFunc)` 根据过滤条件将Collection中的元素转换为Map。
`static <T,K> Map<K,T>`	`convertMapByFilter(Iterable<T> from, Predicate<T> filter, Function<T,K> keyFunc)` 根据过滤条件将Iterable中的元素转换为Map。
`static <T,K> Map<K,T>`	`convertMapByFilter(Stream<T> from, Predicate<T> filter, Function<T,K> keyFunc)` 根据过滤条件将Stream中的元素转换为Map。
`static <T,K> Map<K,T>`	`convertMapByFilter(T[] from, Predicate<T> filter, Function<T,K> keyFunc)` 根据过滤条件将数组中的元素转换为Map。
`static <T,K> Map<K,List<T>>`	`convertMultiMap(Collection<T> from, Function<T,K> keyFunc)` 将Collection中的元素按指定键函数分组，生成一个MultiMap（一个键对应多个值的Map）。
`static <T,K,V> Map<K,List<V>>`	`convertMultiMap(Collection<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将Collection中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map）。
`static <T,K> Map<K,List<T>>`	`convertMultiMap(Iterable<T> from, Function<T,K> keyFunc)` 将Iterable中的元素按指定键函数分组，生成一个MultiMap（一个键对应多个值的Map）。
`static <T,K,V> Map<K,List<V>>`	`convertMultiMap(Iterable<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将Iterable中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map）。
`static <T,K> Map<K,List<T>>`	`convertMultiMap(Stream<T> from, Function<T,K> keyFunc)` 将Stream中的元素按指定键函数分组，生成一个MultiMap（一个键对应多个值的Map）。
`static <T,K,V> Map<K,List<V>>`	`convertMultiMap(Stream<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将Stream中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map）。
`static <T,K> Map<K,List<T>>`	`convertMultiMap(T[] from, Function<T,K> keyFunc)` 将数组中的元素按指定键函数分组，生成一个MultiMap（一个键对应多个值的Map）。
`static <T,K,V> Map<K,List<V>>`	`convertMultiMap(T[] from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将数组中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map）。
`static <T,K,V> Map<K,Set<V>>`	`convertMultiSetMap(Collection<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将Collection中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map），值为LinkedHashSet类型。
`static <T,K,V> Map<K,Set<V>>`	`convertMultiSetMap(Iterable<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将Iterable中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map），值为LinkedHashSet类型。
`static <T,K,V> Map<K,Set<V>>`	`convertMultiSetMap(Stream<T> from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将Stream中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map），值为LinkedHashSet类型。
`static <T,K,V> Map<K,Set<V>>`	`convertMultiSetMap(T[] from, Function<T,K> keyFunc, Function<T,V> valueFunc)` 将数组中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map），值为LinkedHashSet类型。
`static <T> Set<T>`	`convertSet(Collection<T> from)` 将Collection中的元素收集到LinkedHashSet中。
`static <T,U> Set<U>`	`convertSet(Collection<T> from, Function<T,U> func)` 将Collection中的元素进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
`static <T,U> Set<U>`	`convertSet(Collection<T> from, Function<T,U> func, Predicate<T> filter)` 将Collection中的元素先进行过滤，然后进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
`static <T> Set<T>`	`convertSet(Iterable<T> from)` 将Iterable中的元素收集到LinkedHashSet中。
`static <T,U> Set<U>`	`convertSet(Iterable<T> from, Function<T,U> func)` 将Iterable中的元素进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
`static <T,U> Set<U>`	`convertSet(Iterable<T> from, Function<T,U> func, Predicate<T> filter)` 将Iterable中的元素先进行过滤，然后进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
`static <T> Set<T>`	`convertSet(Stream<T> from)` 将Stream中的元素收集到LinkedHashSet中。
`static <T,U> Set<U>`	`convertSet(Stream<T> from, Function<T,U> func)` 将Stream中的元素进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
`static <T,U> Set<U>`	`convertSet(Stream<T> from, Function<T,U> func, Predicate<T> filter)` 将Stream中的元素先进行过滤，然后进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
`static <T> Set<T>`	`convertSet(T[] from)` 将数组中的元素收集到LinkedHashSet中。
`static <T,U> Set<U>`	`convertSet(T[] from, Function<T,U> func)` 将数组中的元素进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
`static <T,U> Set<U>`	`convertSet(T[] from, Function<T,U> func, Predicate<T> filter)` 将数组中的元素先进行过滤，然后进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
`static <T,U,R> Set<R>`	`convertSetByFlatMap(Collection<T> from, Function<? super T,? extends U> mapper, Function<U,? extends Stream<? extends R>> func)` 先将Collection中的元素进行映射，再使用flatMap展开并收集到LinkedHashSet中，过滤掉为null的元素。
`static <T,U> Set<U>`	`convertSetByFlatMap(Collection<T> from, Function<T,? extends Stream<? extends U>> func)` 使用flatMap将Collection中的元素展开并收集到LinkedHashSet中，过滤掉为null的元素。
`static <T,U,R> Set<R>`	`convertSetByFlatMap(Iterable<T> from, Function<? super T,? extends U> mapper, Function<U,? extends Stream<? extends R>> func)` 先将Iterable中的元素进行映射，再使用flatMap展开并收集到LinkedHashSet中，过滤掉为null的元素。
`static <T,U> Set<U>`	`convertSetByFlatMap(Iterable<T> from, Function<T,? extends Stream<? extends U>> func)` 使用flatMap将Iterable中的元素展开并收集到LinkedHashSet中，过滤掉为null的元素。
`static <T,U,R> Set<R>`	`convertSetByFlatMap(Stream<T> from, Function<? super T,? extends U> mapper, Function<U,? extends Stream<? extends R>> func)` 先将Stream中的元素进行映射，再使用flatMap展开并收集到LinkedHashSet中，过滤掉为null的元素。
`static <T,U> Set<U>`	`convertSetByFlatMap(Stream<T> from, Function<T,? extends Stream<? extends U>> func)` 使用flatMap将Stream中的元素展开并收集到LinkedHashSet中，过滤掉为null的元素。
`static <T,U,R> Set<R>`	`convertSetByFlatMap(T[] from, Function<? super T,? extends U> mapper, Function<U,? extends Stream<? extends R>> func)` 先将数组中的元素进行映射，再使用flatMap展开并收集到LinkedHashSet中，过滤掉为null的元素。
`static <T,U> Set<U>`	`convertSetByFlatMap(T[] from, Function<T,? extends Stream<? extends U>> func)` 使用flatMap将数组中的元素展开并收集到LinkedHashSet中，过滤掉为null的元素。
`static <T,R> List<T>`	`distinct(Collection<T> from, Function<T,R> keyMapper)` 根据指定的键映射函数对Collection中的元素进行去重操作。
`static <T,R> List<T>`	`distinct(Collection<T> from, Function<T,R> keyMapper, BinaryOperator<T> cover)` 根据指定的键映射函数对Collection中的元素进行去重操作，使用指定的合并函数处理重复键。
`static <T,R> List<T>`	`distinct(Iterable<T> from, Function<T,R> keyMapper)` 根据指定的键映射函数对Iterable中的元素进行去重操作。
`static <T,R> List<T>`	`distinct(Iterable<T> from, Function<T,R> keyMapper, BinaryOperator<T> cover)` 根据指定的键映射函数对Iterable中的元素进行去重操作，使用指定的合并函数处理重复键。
`static <T,R> List<T>`	`distinct(Stream<T> from, Function<T,R> keyMapper)` 根据指定的键映射函数对Stream中的元素进行去重操作。
`static <T,R> List<T>`	`distinct(Stream<T> from, Function<T,R> keyMapper, BinaryOperator<T> cover)` 根据指定的键映射函数对Stream中的元素进行去重操作，使用指定的合并函数处理重复键。
`static <T,R> List<T>`	`distinct(T[] from, Function<T,R> keyMapper)` 根据指定的键映射函数对数组中的元素进行去重操作。
`static <T,R> List<T>`	`distinct(T[] from, Function<T,R> keyMapper, BinaryOperator<T> cover)` 根据指定的键映射函数对数组中的元素进行去重操作，使用指定的合并函数处理重复键。
`static <T> List<T>`	`filterList(Collection<T> from, Predicate<T> predicate)` 从Collection中过滤出满足条件的元素并收集到List中。
`static <T> List<T>`	`filterList(Iterable<T> from, Predicate<T> predicate)` 从Iterable中过滤出满足条件的元素并收集到List中。
`static <T> List<T>`	`filterList(Stream<T> from, Predicate<T> predicate)` 从Stream中过滤出满足条件的元素并收集到List中。
`static <T> List<T>`	`filterList(T[] from, Predicate<T> predicate)` 从数组中过滤出满足条件的元素并收集到List中。
`static <T> Set<T>`	`filterSet(Collection<T> from, Predicate<T> predicate)` 从Collection中过滤出满足条件的元素并收集到LinkedHashSet中。
`static <T> Set<T>`	`filterSet(Iterable<T> from, Predicate<T> predicate)` 从Iterable中过滤出满足条件的元素并收集到LinkedHashSet中。
`static <T> Set<T>`	`filterSet(Stream<T> from, Predicate<T> predicate)` 从Stream中过滤出满足条件的元素并收集到LinkedHashSet中。
`static <T> Set<T>`	`filterSet(T[] from, Predicate<T> predicate)` 从数组中过滤出满足条件的元素并收集到LinkedHashSet中。
`static <K,V> List<V>`	`mergeValuesFromMap(Map<K,List<V>> map)` 将Map中的所有值(List类型)合并成一个List。
`static <T> Stream<T>`	`stream(Collection<T> collection)` 将Collection转换为Stream。
`static <T> Stream<T>`	`stream(Iterable<T> iterable)` 将Iterable转换为Stream。
`static <T> Stream<T>`	`stream(T[] array)` 将数组转换为Stream。

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
 - Streams
```
public Streams()
```
- 方法详细资料
 - stream
```
public static <T> Stream<T> stream(Iterable<T> iterable)
```
 将Iterable转换为Stream。
 
 类型参数:
 
 T - Iterable中元素的类型
 
 参数:
 
 iterable - 要转换的Iterable对象，可以为null
 
 返回:
 
 转换后的Stream，如果iterable为null则返回空Stream
 - stream
```
public static <T> Stream<T> stream(Collection<T> collection)
```
 将Collection转换为Stream。
 
 类型参数:
 
 T - Collection中元素的类型
 
 参数:
 
 collection - 要转换的Collection对象，可以为null
 
 返回:
 
 转换后的Stream，如果collection为null则返回空Stream
 - stream
```
public static <T> Stream<T> stream(T[] array)
```
 将数组转换为Stream。
 
 类型参数:
 
 T - 数组中元素的类型
 
 参数:
 
 array - 要转换的数组，可以为null
 
 返回:
 
 转换后的Stream，如果array为null则返回空Stream
 - filterList
```
public static <T> List<T> filterList(Stream<T> from,
 Predicate<T> predicate)
```
 从Stream中过滤出满足条件的元素并收集到List中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源Stream，可以为null
 
 predicate - 过滤条件，用于判断元素是否应该被保留
 
 返回:
 
 包含满足条件元素的List，如果from为null则返回空List
 - filterList
```
public static <T> List<T> filterList(Iterable<T> from,
 Predicate<T> predicate)
```
 从Iterable中过滤出满足条件的元素并收集到List中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空List
 
 predicate - 过滤条件，用于判断元素是否应该被保留
 
 返回:
 
 包含满足条件元素的List，如果from为空则返回空List
 - filterList
```
public static <T> List<T> filterList(T[] from,
 Predicate<T> predicate)
```
 从数组中过滤出满足条件的元素并收集到List中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源数组，如果为空则返回空List
 
 predicate - 过滤条件，用于判断元素是否应该被保留
 
 返回:
 
 包含满足条件元素的List，如果from为空则返回空List
 - filterList
```
public static <T> List<T> filterList(Collection<T> from,
 Predicate<T> predicate)
```
 从Collection中过滤出满足条件的元素并收集到List中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源Collection，如果为空则返回空List
 
 predicate - 过滤条件，用于判断元素是否应该被保留
 
 返回:
 
 包含满足条件元素的List，如果from为空则返回空List
 - filterSet
```
public static <T> Set<T> filterSet(Stream<T> from,
 Predicate<T> predicate)
```
 从Stream中过滤出满足条件的元素并收集到LinkedHashSet中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashSet
 
 predicate - 过滤条件，用于判断元素是否应该被保留
 
 返回:
 
 包含满足条件元素的LinkedHashSet，如果from为null则返回空LinkedHashSet
 - filterSet
```
public static <T> Set<T> filterSet(Iterable<T> from,
 Predicate<T> predicate)
```
 从Iterable中过滤出满足条件的元素并收集到LinkedHashSet中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashSet
 
 predicate - 过滤条件，用于判断元素是否应该被保留
 
 返回:
 
 包含满足条件元素的LinkedHashSet，如果from为空则返回空LinkedHashSet
 - filterSet
```
public static <T> Set<T> filterSet(T[] from,
 Predicate<T> predicate)
```
 从数组中过滤出满足条件的元素并收集到LinkedHashSet中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashSet
 
 predicate - 过滤条件，用于判断元素是否应该被保留
 
 返回:
 
 包含满足条件元素的LinkedHashSet，如果from为空则返回空LinkedHashSet
 - filterSet
```
public static <T> Set<T> filterSet(Collection<T> from,
 Predicate<T> predicate)
```
 从Collection中过滤出满足条件的元素并收集到LinkedHashSet中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashSet
 
 predicate - 过滤条件，用于判断元素是否应该被保留
 
 返回:
 
 包含满足条件元素的LinkedHashSet，如果from为空则返回空LinkedHashSet
 - convertList
```
public static <T,U> List convertList(Stream<T> from,
 Function<T,U> func)
```
 将Stream中的元素进行类型转换并收集到List中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Stream，如果为null则返回空List
 
 func - 转换函数，用于将源类型转换为目标类型
 
 返回:
 
 包含转换后元素的List，不包含null元素，如果from为null则返回空List
 - convertList
```
public static <T,U> List convertList(Iterable<T> from,
 Function<T,U> func)
```
 将Iterable中的元素进行类型转换并收集到List中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空List
 
 func - 转换函数，用于将源类型转换为目标类型
 
 返回:
 
 包含转换后元素的List，不包含null元素，如果from为空则返回空List
 - convertList
```
public static <T,U> List convertList(T[] from,
 Function<T,U> func)
```
 将数组中的元素进行类型转换并收集到List中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源数组，如果为空则返回空List
 
 func - 转换函数，用于将源类型转换为目标类型
 
 返回:
 
 包含转换后元素的List，不包含null元素，如果from为空则返回空List
 - convertList
```
public static <T,U> List convertList(Collection<T> from,
 Function<T,U> func)
```
 将Collection中的元素进行类型转换并收集到List中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Collection，如果为空则返回空List
 
 func - 转换函数，用于将源类型转换为目标类型
 
 返回:
 
 包含转换后元素的List，不包含null元素，如果from为空则返回空List
 - convertList
```
public static <T,U> List convertList(Stream<T> from,
 Function<T,U> func,
 Predicate<T> filter)
```
 将Stream中的元素先进行过滤，然后进行类型转换并收集到List中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Stream，如果为null则返回空List
 
 func - 转换函数，用于将源类型转换为目标类型
 
 filter - 过滤条件，用于判断元素是否应该被处理
 
 返回:
 
 包含过滤和转换后元素的List，不包含null元素，如果from为null则返回空List
 - convertList
```
public static <T,U> List convertList(Iterable<T> from,
 Function<T,U> func,
 Predicate<T> filter)
```
 将Iterable中的元素先进行过滤，然后进行类型转换并收集到List中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空List
 
 func - 转换函数，用于将源类型转换为目标类型
 
 filter - 过滤条件，用于判断元素是否应该被处理
 
 返回:
 
 包含过滤和转换后元素的List，不包含null元素，如果from为空则返回空List
 - convertList
```
public static <T,U> List convertList(T[] from,
 Function<T,U> func,
 Predicate<T> filter)
```
 将数组中的元素先进行过滤，然后进行类型转换并收集到List中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源数组，如果为空则返回空List
 
 func - 转换函数，用于将源类型转换为目标类型
 
 filter - 过滤条件，用于判断元素是否应该被处理
 
 返回:
 
 包含过滤和转换后元素的List，不包含null元素，如果from为空则返回空List
 - convertList
```
public static <T,U> List convertList(Collection<T> from,
 Function<T,U> func,
 Predicate<T> filter)
```
 将Collection中的元素先进行过滤，然后进行类型转换并收集到List中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Collection，如果为空则返回空List
 
 func - 转换函数，用于将源类型转换为目标类型
 
 filter - 过滤条件，用于判断元素是否应该被处理
 
 返回:
 
 包含过滤和转换后元素的List，不包含null元素，如果from为空则返回空List
 - convertListByFlatMap
```
public static <T,U> List convertListByFlatMap(Stream<T> from,
 Function<T,? extends Stream<? extends U>> func)
```
 使用flatMap将Stream中的元素展开并收集到List中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 展开后元素的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空List
 
 func - 展开函数，将每个元素转换为Stream
 
 返回:
 
 包含展开后元素的List，不包含null元素，如果from为null则返回空List
 - convertListByFlatMap
```
public static <T,U> List convertListByFlatMap(Iterable<T> from,
 Function<T,? extends Stream<? extends U>> func)
```
 使用flatMap将Iterable中的元素展开并收集到List中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 展开后元素的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空List
 
 func - 展开函数，将每个元素转换为Stream
 
 返回:
 
 包含展开后元素的List，不包含null元素，如果from为空则返回空List
 - convertListByFlatMap
```
public static <T,U> List convertListByFlatMap(T[] from,
 Function<T,? extends Stream<? extends U>> func)
```
 使用flatMap将数组中的元素展开并收集到List中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 展开后元素的类型
 
 参数:
 
 from - 源数组，如果为空则返回空List
 
 func - 展开函数，将每个元素转换为Stream
 
 返回:
 
 包含展开后元素的List，不包含null元素，如果from为空则返回空List
 - convertListByFlatMap
```
public static <T,U> List convertListByFlatMap(Collection<T> from,
 Function<T,? extends Stream<? extends U>> func)
```
 使用flatMap将Collection中的元素展开并收集到List中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 展开后元素的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空List
 
 func - 展开函数，将每个元素转换为Stream
 
 返回:
 
 包含展开后元素的List，不包含null元素，如果from为空则返回空List
 - convertListByFlatMap
```
public static <T,U,R> List<R> convertListByFlatMap(Stream<T> from,
 Function<? super T,? extends U> mapper,
 Function<U,? extends Stream<? extends R>> func)
```
 先将Stream中的元素进行映射，再使用flatMap展开并收集到List中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 中间映射后的类型
 
 R - 展开后元素的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空List
 
 mapper - 映射函数，将源类型转换为中间类型
 
 func - 展开函数，将中间类型转换为Stream
 
 返回:
 
 包含映射和展开后元素的List，不包含null元素，如果from为null则返回空List
 - convertListByFlatMap
```
public static <T,U,R> List<R> convertListByFlatMap(Iterable<T> from,
 Function<? super T,? extends U> mapper,
 Function<U,? extends Stream<? extends R>> func)
```
 先将Iterable中的元素进行映射，再使用flatMap展开并收集到List中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 中间映射后的类型
 
 R - 展开后元素的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空List
 
 mapper - 映射函数，将源类型转换为中间类型
 
 func - 展开函数，将中间类型转换为Stream
 
 返回:
 
 包含映射和展开后元素的List，不包含null元素，如果from为空则返回空List
 - convertListByFlatMap
```
public static <T,U,R> List<R> convertListByFlatMap(T[] from,
 Function<? super T,? extends U> mapper,
 Function<U,? extends Stream<? extends R>> func)
```
 先将数组中的元素进行映射，再使用flatMap展开并收集到List中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 中间映射后的类型
 
 R - 展开后元素的类型
 
 参数:
 
 from - 源数组，如果为空则返回空List
 
 mapper - 映射函数，将源类型转换为中间类型
 
 func - 展开函数，将中间类型转换为Stream
 
 返回:
 
 包含映射和展开后元素的List，不包含null元素，如果from为空则返回空List
 - convertListByFlatMap
```
public static <T,U,R> List<R> convertListByFlatMap(Collection<T> from,
 Function<? super T,? extends U> mapper,
 Function<U,? extends Stream<? extends R>> func)
```
 先将Collection中的元素进行映射，再使用flatMap展开并收集到List中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 中间映射后的类型
 
 R - 展开后元素的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空List
 
 mapper - 映射函数，将源类型转换为中间类型
 
 func - 展开函数，将中间类型转换为Stream
 
 返回:
 
 包含映射和展开后元素的List，不包含null元素，如果from为空则返回空List
 - mergeValuesFromMap
```
public static <K,V> List<V> mergeValuesFromMap(Map<K,List<V>> map)
```
 将Map中的所有值(List类型)合并成一个List。
 
 类型参数:
 
 K - Map的键类型
 
 V - Map的值中List的元素类型
 
 参数:
 
 map - 源Map，其中值为List类型
 
 返回:
 
 包含所有List中元素的List
 - convertSet
```
public static <T,U> Set convertSet(Stream<T> from,
 Function<T,U> func)
```
 将Stream中的元素进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashSet
 
 func - 转换函数，用于将源类型转换为目标类型
 
 返回:
 
 包含转换后元素的LinkedHashSet，不包含null元素，如果from为null则返回空LinkedHashSet
 - convertSet
```
public static <T,U> Set convertSet(Iterable<T> from,
 Function<T,U> func)
```
 将Iterable中的元素进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashSet
 
 func - 转换函数，用于将源类型转换为目标类型
 
 返回:
 
 包含转换后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertSet
```
public static <T,U> Set convertSet(T[] from,
 Function<T,U> func)
```
 将数组中的元素进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashSet
 
 func - 转换函数，用于将源类型转换为目标类型
 
 返回:
 
 包含转换后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertSet
```
public static <T,U> Set convertSet(Collection<T> from,
 Function<T,U> func)
```
 将Collection中的元素进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashSet
 
 func - 转换函数，用于将源类型转换为目标类型
 
 返回:
 
 包含转换后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertSet
```
public static <T> Set<T> convertSet(Stream<T> from)
```
 将Stream中的元素收集到LinkedHashSet中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashSet
 
 返回:
 
 包含元素的LinkedHashSet，如果from为null则返回空LinkedHashSet
 - convertSet
```
public static <T> Set<T> convertSet(Iterable<T> from)
```
 将Iterable中的元素收集到LinkedHashSet中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashSet
 
 返回:
 
 包含元素的LinkedHashSet，如果from为空则返回空LinkedHashSet
 - convertSet
```
public static <T> Set<T> convertSet(T[] from)
```
 将数组中的元素收集到LinkedHashSet中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashSet
 
 返回:
 
 包含元素的LinkedHashSet，如果from为空则返回空LinkedHashSet
 - convertSet
```
public static <T> Set<T> convertSet(Collection<T> from)
```
 将Collection中的元素收集到LinkedHashSet中。
 
 类型参数:
 
 T - 元素类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashSet
 
 返回:
 
 包含元素的LinkedHashSet，如果from为空则返回空LinkedHashSet
 - convertSet
```
public static <T,U> Set convertSet(Stream<T> from,
 Function<T,U> func,
 Predicate<T> filter)
```
 将Stream中的元素先进行过滤，然后进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashSet
 
 func - 转换函数，用于将源类型转换为目标类型
 
 filter - 过滤条件，用于判断元素是否应该被处理
 
 返回:
 
 包含过滤和转换后元素的LinkedHashSet，不包含null元素，如果from为null则返回空LinkedHashSet
 - convertSet
```
public static <T,U> Set convertSet(Iterable<T> from,
 Function<T,U> func,
 Predicate<T> filter)
```
 将Iterable中的元素先进行过滤，然后进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashSet
 
 func - 转换函数，用于将源类型转换为目标类型
 
 filter - 过滤条件，用于判断元素是否应该被处理
 
 返回:
 
 包含过滤和转换后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertSet
```
public static <T,U> Set convertSet(T[] from,
 Function<T,U> func,
 Predicate<T> filter)
```
 将数组中的元素先进行过滤，然后进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashSet
 
 func - 转换函数，用于将源类型转换为目标类型
 
 filter - 过滤条件，用于判断元素是否应该被处理
 
 返回:
 
 包含过滤和转换后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertSet
```
public static <T,U> Set convertSet(Collection<T> from,
 Function<T,U> func,
 Predicate<T> filter)
```
 将Collection中的元素先进行过滤，然后进行类型转换并收集到LinkedHashSet中，过滤掉转换后为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 目标元素类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashSet
 
 func - 转换函数，用于将源类型转换为目标类型
 
 filter - 过滤条件，用于判断元素是否应该被处理
 
 返回:
 
 包含过滤和转换后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertMapByFilter
```
public static <T,K> Map<K,T> convertMapByFilter(Stream<T> from,
 Predicate<T> filter,
 Function<T,K> keyFunc)
```
 根据过滤条件将Stream中的元素转换为Map。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashMap
 
 filter - 过滤条件，用于判断元素是否应该被包含在结果中
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含过滤后元素的LinkedHashMap，如果from为null则返回空LinkedHashMap
 - convertMapByFilter
```
public static <T,K> Map<K,T> convertMapByFilter(Iterable<T> from,
 Predicate<T> filter,
 Function<T,K> keyFunc)
```
 根据过滤条件将Iterable中的元素转换为Map。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashMap
 
 filter - 过滤条件，用于判断元素是否应该被包含在结果中
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含过滤后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertMapByFilter
```
public static <T,K> Map<K,T> convertMapByFilter(T[] from,
 Predicate<T> filter,
 Function<T,K> keyFunc)
```
 根据过滤条件将数组中的元素转换为Map。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashMap
 
 filter - 过滤条件，用于判断元素是否应该被包含在结果中
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含过滤后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertMapByFilter
```
public static <T,K> Map<K,T> convertMapByFilter(Collection<T> from,
 Predicate<T> filter,
 Function<T,K> keyFunc)
```
 根据过滤条件将Collection中的元素转换为Map。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashMap
 
 filter - 过滤条件，用于判断元素是否应该被包含在结果中
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含过滤后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertSetByFlatMap
```
public static <T,U> Set convertSetByFlatMap(Stream<T> from,
 Function<T,? extends Stream<? extends U>> func)
```
 使用flatMap将Stream中的元素展开并收集到LinkedHashSet中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 展开后元素的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashSet
 
 func - 展开函数，将每个元素转换为Stream
 
 返回:
 
 包含展开后元素的LinkedHashSet，不包含null元素，如果from为null则返回空LinkedHashSet
 - convertSetByFlatMap
```
public static <T,U> Set convertSetByFlatMap(Iterable<T> from,
 Function<T,? extends Stream<? extends U>> func)
```
 使用flatMap将Iterable中的元素展开并收集到LinkedHashSet中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 展开后元素的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashSet
 
 func - 展开函数，将每个元素转换为Stream
 
 返回:
 
 包含展开后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertSetByFlatMap
```
public static <T,U> Set convertSetByFlatMap(T[] from,
 Function<T,? extends Stream<? extends U>> func)
```
 使用flatMap将数组中的元素展开并收集到LinkedHashSet中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 展开后元素的类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashSet
 
 func - 展开函数，将每个元素转换为Stream
 
 返回:
 
 包含展开后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertSetByFlatMap
```
public static <T,U> Set convertSetByFlatMap(Collection<T> from,
 Function<T,? extends Stream<? extends U>> func)
```
 使用flatMap将Collection中的元素展开并收集到LinkedHashSet中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 展开后元素的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashSet
 
 func - 展开函数，将每个元素转换为Stream
 
 返回:
 
 包含展开后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertSetByFlatMap
```
public static <T,U,R> Set<R> convertSetByFlatMap(Stream<T> from,
 Function<? super T,? extends U> mapper,
 Function<U,? extends Stream<? extends R>> func)
```
 先将Stream中的元素进行映射，再使用flatMap展开并收集到LinkedHashSet中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 中间映射后的类型
 
 R - 展开后元素的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashSet
 
 mapper - 映射函数，将源类型转换为中间类型
 
 func - 展开函数，将中间类型转换为Stream
 
 返回:
 
 包含映射和展开后元素的LinkedHashSet，不包含null元素，如果from为null则返回空LinkedHashSet
 - convertSetByFlatMap
```
public static <T,U,R> Set<R> convertSetByFlatMap(Iterable<T> from,
 Function<? super T,? extends U> mapper,
 Function<U,? extends Stream<? extends R>> func)
```
 先将Iterable中的元素进行映射，再使用flatMap展开并收集到LinkedHashSet中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 中间映射后的类型
 
 R - 展开后元素的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashSet
 
 mapper - 映射函数，将源类型转换为中间类型
 
 func - 展开函数，将中间类型转换为Stream
 
 返回:
 
 包含映射和展开后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertSetByFlatMap
```
public static <T,U,R> Set<R> convertSetByFlatMap(T[] from,
 Function<? super T,? extends U> mapper,
 Function<U,? extends Stream<? extends R>> func)
```
 先将数组中的元素进行映射，再使用flatMap展开并收集到LinkedHashSet中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 中间映射后的类型
 
 R - 展开后元素的类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashSet
 
 mapper - 映射函数，将源类型转换为中间类型
 
 func - 展开函数，将中间类型转换为Stream
 
 返回:
 
 包含映射和展开后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertSetByFlatMap
```
public static <T,U,R> Set<R> convertSetByFlatMap(Collection<T> from,
 Function<? super T,? extends U> mapper,
 Function<U,? extends Stream<? extends R>> func)
```
 先将Collection中的元素进行映射，再使用flatMap展开并收集到LinkedHashSet中，过滤掉为null的元素。
 
 类型参数:
 
 T - 源元素类型
 
 U - 中间映射后的类型
 
 R - 展开后元素的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashSet
 
 mapper - 映射函数，将源类型转换为中间类型
 
 func - 展开函数，将中间类型转换为Stream
 
 返回:
 
 包含映射和展开后元素的LinkedHashSet，不包含null元素，如果from为空则返回空LinkedHashSet
 - convertMap
```
public static <T,K> Map<K,T> convertMap(Stream<T> from,
 Function<T,K> keyFunc)
```
 将Stream中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为null则返回空LinkedHashMap
 - convertMap
```
public static <T,K> Map<K,T> convertMap(Iterable<T> from,
 Function<T,K> keyFunc)
```
 将Iterable中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertMap
```
public static <T,K> Map<K,T> convertMap(T[] from,
 Function<T,K> keyFunc)
```
 将数组中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertMap
```
public static <T,K> Map<K,T> convertMap(Collection<T> from,
 Function<T,K> keyFunc)
```
 将Collection中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Stream<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将Stream中的元素转换为Map，使用指定的键映射函数和值映射函数。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为null则返回空LinkedHashMap
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Iterable<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将Iterable中的元素转换为Map，使用指定的键映射函数和值映射函数。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(T[] from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将数组中的元素转换为Map，使用指定的键映射函数和值映射函数。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Collection<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将Collection中的元素转换为Map，使用指定的键映射函数和值映射函数。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertMap
```
public static <T,K> Map<K,T> convertMap(Stream<T> from,
 Function<T,K> keyFunc,
 Supplier<? extends Map<K,T>> supplier)
```
 将Stream中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())，并指定Map的实现类型。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Stream，如果为null则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为null则返回由supplier创建的空Map
 - convertMap
```
public static <T,K> Map<K,T> convertMap(Iterable<T> from,
 Function<T,K> keyFunc,
 Supplier<? extends Map<K,T>> supplier)
```
 将Iterable中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())，并指定Map的实现类型。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为空则返回由supplier创建的空Map
 - convertMap
```
public static <T,K> Map<K,T> convertMap(T[] from,
 Function<T,K> keyFunc,
 Supplier<? extends Map<K,T>> supplier)
```
 将数组中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())，并指定Map的实现类型。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源数组，如果为空则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为空则返回由supplier创建的空Map
 - convertMap
```
public static <T,K> Map<K,T> convertMap(Collection<T> from,
 Function<T,K> keyFunc,
 Supplier<? extends Map<K,T>> supplier)
```
 将Collection中的元素转换为Map，使用指定的键映射函数和默认的值映射函数(Function.identity())，并指定Map的实现类型。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Collection，如果为空则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为空则返回由supplier创建的空Map
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Stream<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 BinaryOperator<V> mergeFunction)
```
 将Stream中的元素转换为Map，使用指定的键映射函数、值映射函数和合并函数。默认使用LinkedHashMap作为Map的实现类型。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 mergeFunction - 合并函数，用于处理键冲突的情况
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为null则返回空LinkedHashMap
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Iterable<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 BinaryOperator<V> mergeFunction)
```
 将Iterable中的元素转换为Map，使用指定的键映射函数、值映射函数和合并函数。默认使用LinkedHashMap作为Map的实现类型。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 mergeFunction - 合并函数，用于处理键冲突的情况
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(T[] from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 BinaryOperator<V> mergeFunction)
```
 将数组中的元素转换为Map，使用指定的键映射函数、值映射函数和合并函数。默认使用LinkedHashMap作为Map的实现类型。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 mergeFunction - 合并函数，用于处理键冲突的情况
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Collection<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 BinaryOperator<V> mergeFunction)
```
 将Collection中的元素转换为Map，使用指定的键映射函数、值映射函数和合并函数。默认使用LinkedHashMap作为Map的实现类型。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 mergeFunction - 合并函数，用于处理键冲突的情况
 
 返回:
 
 包含转换后元素的LinkedHashMap，如果from为空则返回空LinkedHashMap
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Stream<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 Supplier<? extends Map<K,V>> supplier)
```
 将Stream中的元素转换为Map，使用指定的键映射函数、值映射函数和Map供应商。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Stream，如果为null则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为null则返回由supplier创建的空Map
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Iterable<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 Supplier<? extends Map<K,V>> supplier)
```
 将Iterable中的元素转换为Map，使用指定的键映射函数、值映射函数和Map供应商。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为空则返回由supplier创建的空Map
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(T[] from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 Supplier<? extends Map<K,V>> supplier)
```
 将数组中的元素转换为Map，使用指定的键映射函数、值映射函数和Map供应商。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源数组，如果为空则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为空则返回由supplier创建的空Map
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Collection<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 Supplier<? extends Map<K,V>> supplier)
```
 将Collection中的元素转换为Map，使用指定的键映射函数、值映射函数和Map供应商。当出现键冲突时，使用(v1, v2) -> v1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Collection，如果为空则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为空则返回由supplier创建的空Map
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Stream<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 BinaryOperator<V> mergeFunction,
 Supplier<? extends Map<K,V>> supplier)
```
 将Stream中的元素转换为Map，使用指定的键映射函数、值映射函数、合并函数和Map供应商。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Stream，如果为null则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 mergeFunction - 合并函数，用于处理键冲突的情况
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为null则返回由supplier创建的空Map
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Iterable<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 BinaryOperator<V> mergeFunction,
 Supplier<? extends Map<K,V>> supplier)
```
 将Iterable中的元素转换为Map，使用指定的键映射函数、值映射函数、合并函数和Map供应商。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 mergeFunction - 合并函数，用于处理键冲突的情况
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为空则返回由supplier创建的空Map
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(T[] from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 BinaryOperator<V> mergeFunction,
 Supplier<? extends Map<K,V>> supplier)
```
 将数组中的元素转换为Map，使用指定的键映射函数、值映射函数、合并函数和Map供应商。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源数组，如果为空则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 mergeFunction - 合并函数，用于处理键冲突的情况
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为空则返回由supplier创建的空Map
 - convertMap
```
public static <T,K,V> Map<K,V> convertMap(Collection<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc,
 BinaryOperator<V> mergeFunction,
 Supplier<? extends Map<K,V>> supplier)
```
 将Collection中的元素转换为Map，使用指定的键映射函数、值映射函数、合并函数和Map供应商。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Collection，如果为空则返回由supplier创建的空Map
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 mergeFunction - 合并函数，用于处理键冲突的情况
 
 supplier - Map供应商，用于创建Map实例
 
 返回:
 
 包含转换后元素的Map，如果from为空则返回由supplier创建的空Map
 - convertMultiMap
```
public static <T,K> Map<K,List<T>> convertMultiMap(Stream<T> from,
 Function<T,K> keyFunc)
```
 将Stream中的元素按指定键函数分组，生成一个MultiMap（一个键对应多个值的Map）。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含分组后元素的LinkedHashMap，键为分组依据，值为该组的所有元素列表
 - convertMultiMap
```
public static <T,K> Map<K,List<T>> convertMultiMap(Iterable<T> from,
 Function<T,K> keyFunc)
```
 将Iterable中的元素按指定键函数分组，生成一个MultiMap（一个键对应多个值的Map）。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含分组后元素的LinkedHashMap，键为分组依据，值为该组的所有元素列表
 - convertMultiMap
```
public static <T,K> Map<K,List<T>> convertMultiMap(T[] from,
 Function<T,K> keyFunc)
```
 将数组中的元素按指定键函数分组，生成一个MultiMap（一个键对应多个值的Map）。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含分组后元素的LinkedHashMap，键为分组依据，值为该组的所有元素列表
 - convertMultiMap
```
public static <T,K> Map<K,List<T>> convertMultiMap(Collection<T> from,
 Function<T,K> keyFunc)
```
 将Collection中的元素按指定键函数分组，生成一个MultiMap（一个键对应多个值的Map）。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 返回:
 
 包含分组后元素的LinkedHashMap，键为分组依据，值为该组的所有元素列表
 - convertMultiMap
```
public static <T,K,V> Map<K,List<V>> convertMultiMap(Stream<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将Stream中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map）。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含分组和转换后元素的LinkedHashMap，键为分组依据，值为该组的所有元素列表
 - convertMultiMap
```
public static <T,K,V> Map<K,List<V>> convertMultiMap(Iterable<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将Iterable中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map）。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含分组和转换后元素的LinkedHashMap，键为分组依据，值为该组的所有元素列表
 - convertMultiMap
```
public static <T,K,V> Map<K,List<V>> convertMultiMap(T[] from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将数组中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map）。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含分组和转换后元素的LinkedHashMap，键为分组依据，值为该组的所有元素列表
 - convertMultiMap
```
public static <T,K,V> Map<K,List<V>> convertMultiMap(Collection<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将Collection中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map）。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含分组和转换后元素的LinkedHashMap，键为分组依据，值为该组的所有元素列表
 - convertMultiSetMap
```
public static <T,K,V> Map<K,Set<V>> convertMultiSetMap(Stream<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将Stream中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map），值为LinkedHashSet类型。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含分组和转换后元素的LinkedHashMap，键为分组依据，值为该组的所有元素集合（LinkedHashSet）
 - convertMultiSetMap
```
public static <T,K,V> Map<K,Set<V>> convertMultiSetMap(Iterable<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将Iterable中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map），值为LinkedHashSet类型。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含分组和转换后元素的LinkedHashMap，键为分组依据，值为该组的所有元素集合（LinkedHashSet）
 - convertMultiSetMap
```
public static <T,K,V> Map<K,Set<V>> convertMultiSetMap(T[] from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将数组中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map），值为LinkedHashSet类型。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源数组，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含分组和转换后元素的LinkedHashMap，键为分组依据，值为该组的所有元素集合（LinkedHashSet）
 - convertMultiSetMap
```
public static <T,K,V> Map<K,Set<V>> convertMultiSetMap(Collection<T> from,
 Function<T,K> keyFunc,
 Function<T,V> valueFunc)
```
 将Collection中的元素按指定键函数分组，并对值进行转换，生成一个MultiMap（一个键对应多个值的Map），值为LinkedHashSet类型。
 
 类型参数:
 
 T - 元素类型
 
 K - Map键的类型
 
 V - Map值的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空LinkedHashMap
 
 keyFunc - 键映射函数，用于从元素生成键
 
 valueFunc - 值映射函数，用于从元素生成值
 
 返回:
 
 包含分组和转换后元素的LinkedHashMap，键为分组依据，值为该组的所有元素集合（LinkedHashSet）
 - distinct
```
public static <T,R> List<T> distinct(Stream<T> from,
 Function<T,R> keyMapper)
```
 根据指定的键映射函数对Stream中的元素进行去重操作。当出现重复键时，使用(t1, t2) -> t1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 R - 键的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空ArrayList
 
 keyMapper - 键映射函数，用于生成元素的键
 
 返回:
 
 去重后的元素列表
 - distinct
```
public static <T,R> List<T> distinct(Iterable<T> from,
 Function<T,R> keyMapper)
```
 根据指定的键映射函数对Iterable中的元素进行去重操作。当出现重复键时，使用(t1, t2) -> t1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 R - 键的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空ArrayList
 
 keyMapper - 键映射函数，用于生成元素的键
 
 返回:
 
 去重后的元素列表
 - distinct
```
public static <T,R> List<T> distinct(T[] from,
 Function<T,R> keyMapper)
```
 根据指定的键映射函数对数组中的元素进行去重操作。当出现重复键时，使用(t1, t2) -> t1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 R - 键的类型
 
 参数:
 
 from - 源数组，如果为空则返回空ArrayList
 
 keyMapper - 键映射函数，用于生成元素的键
 
 返回:
 
 去重后的元素列表
 - distinct
```
public static <T,R> List<T> distinct(Collection<T> from,
 Function<T,R> keyMapper)
```
 根据指定的键映射函数对Collection中的元素进行去重操作。当出现重复键时，使用(t1, t2) -> t1作为合并函数。
 
 类型参数:
 
 T - 元素类型
 
 R - 键的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空ArrayList
 
 keyMapper - 键映射函数，用于生成元素的键
 
 返回:
 
 去重后的元素列表
 - distinct
```
public static <T,R> List<T> distinct(Stream<T> from,
 Function<T,R> keyMapper,
 BinaryOperator<T> cover)
```
 根据指定的键映射函数对Stream中的元素进行去重操作，使用指定的合并函数处理重复键。
 
 类型参数:
 
 T - 元素类型
 
 R - 键的类型
 
 参数:
 
 from - 源Stream，如果为null则返回空ArrayList
 
 keyMapper - 键映射函数，用于生成元素的键
 
 cover - 合并函数，用于处理键冲突的情况
 
 返回:
 
 去重后的元素列表
 - distinct
```
public static <T,R> List<T> distinct(Iterable<T> from,
 Function<T,R> keyMapper,
 BinaryOperator<T> cover)
```
 根据指定的键映射函数对Iterable中的元素进行去重操作，使用指定的合并函数处理重复键。
 
 类型参数:
 
 T - 元素类型
 
 R - 键的类型
 
 参数:
 
 from - 源Iterable，如果为空则返回空ArrayList
 
 keyMapper - 键映射函数，用于生成元素的键
 
 cover - 合并函数，用于处理键冲突的情况
 
 返回:
 
 去重后的元素列表
 - distinct
```
public static <T,R> List<T> distinct(T[] from,
 Function<T,R> keyMapper,
 BinaryOperator<T> cover)
```
 根据指定的键映射函数对数组中的元素进行去重操作，使用指定的合并函数处理重复键。
 
 类型参数:
 
 T - 元素类型
 
 R - 键的类型
 
 参数:
 
 from - 源数组，如果为空则返回空ArrayList
 
 keyMapper - 键映射函数，用于生成元素的键
 
 cover - 合并函数，用于处理键冲突的情况
 
 返回:
 
 去重后的元素列表
 - distinct
```
public static <T,R> List<T> distinct(Collection<T> from,
 Function<T,R> keyMapper,
 BinaryOperator<T> cover)
```
 根据指定的键映射函数对Collection中的元素进行去重操作，使用指定的合并函数处理重复键。
 
 类型参数:
 
 T - 元素类型
 
 R - 键的类型
 
 参数:
 
 from - 源Collection，如果为空则返回空ArrayList
 
 keyMapper - 键映射函数，用于生成元素的键
 
 cover - 合并函数，用于处理键冲突的情况
 
 返回:
 
 去重后的元素列表

类 Streams

构造器概要

方法概要

从类继承的方法 java.lang.Object

构造器详细资料

Streams

方法详细资料

stream

stream

stream

filterList

filterList

filterList

filterList

filterSet

filterSet

filterSet

filterSet

convertList

convertList

convertList

convertList

convertList

convertList

convertList

convertList

convertListByFlatMap

convertListByFlatMap

convertListByFlatMap

convertListByFlatMap

convertListByFlatMap

convertListByFlatMap

convertListByFlatMap

convertListByFlatMap

mergeValuesFromMap

convertSet

convertSet

convertSet

convertSet

convertSet

convertSet

convertSet

convertSet

convertSet

convertSet

convertSet

convertSet

convertMapByFilter

convertMapByFilter

convertMapByFilter

convertMapByFilter

convertSetByFlatMap

convertSetByFlatMap

convertSetByFlatMap

convertSetByFlatMap

convertSetByFlatMap

convertSetByFlatMap

convertSetByFlatMap

convertSetByFlatMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap

convertMap