程序包 cn.woodwhales.common.business

类 DataTool

java.lang.Object

cn.woodwhales.common.business.DataTool

public class DataTool
extends Object

业务处理工具类

作者:

woodwhales 2020-11-17 13:44

构造器概要

构造器

构造器	说明
DataTool()

方法概要

修饰符和类型	方法	说明
static <K,T> DeduplicateResult<K,T>	deduplicate(List<T> source, java.util.function.Function<T,Boolean> isValidFunction, java.util.function.Function<T,K> getDeduplicatedKeyFunction)	对集合数据进行去重器, 默认保留最后出现的重复元素 非线程安全
static <K,T> DeduplicateResult<K,T>	deduplicate(List<T> source, java.util.function.Function<T,Boolean> isValidFunction, java.util.function.Function<T,K> getDeduplicatedKeyFunction, boolean remainFirst)	对集合数据进行去重器 非线程安全
static <K,T> DeduplicateResult<K,T>	deduplicate(List<T> source, java.util.function.Function<T,K> getDeduplicatedKeyFunction)	对集合数据进行去重器, 默认保留最后出现的重复元素 非线程安全
static <K,T> DeduplicateResult<K,T>	deduplicate(List<T> source, java.util.function.Function<T,K> getDeduplicatedKeyFunction, boolean remainFirst)	对集合数据进行去重器 非线程安全
static <K,T extends Enum<T>> boolean	enumContainsKey(K key, Class<T> sourceEnumClass, java.util.function.Function<T,K> keyMapper)	判断 key 是否存在于枚举转 map 的集合中
static <K,T extends Enum<T>> T	enumGetValue(K key, Class<T> sourceEnumClass, java.util.function.Function<T,K> keyMapper)	根据 key 获取对应的枚举实例
static <K,S extends Enum<S>> Map<K,List<S>>	enumGroupingBy(Class<S> sourceEnumClass, java.util.function.Function<? super S,? extends K> classifier)	将 枚举分组 集合分组
static <T extends Enum<T>,R> List<R>	enumList(Class<T> sourceEnumClass, java.util.function.Function<T,R> function)	枚举转 list 集合 按照 function 将枚举转成 list 集合
static <T extends Enum<T>> Map<String,T>	enumMap(Class<T> sourceEnumClass)	枚举转 map 集合 map 集合中的 key 为 Enum 的 name() 方法返回值
static <K,T extends Enum<T>> Map<K,T>	enumMap(Class<T> sourceEnumClass, java.util.function.Function<T,K> keyMapper)	枚举转 map 集合
static <K,V,T extends Enum<T>> Map<K,V>	enumMap(Class<T> sourceEnumClass, java.util.function.Function<T,K> keyMapper, java.util.function.Function<T,V> valueMapper)	枚举转 map 集合
static <T> List<T>	filter(List<T> source, java.util.function.Predicate<? super T> filter)	将原始的 list 按照 filter 过滤
static <T> List<T>	filter(T[] source, java.util.function.Predicate<? super T> filter)	将原始的 list 按照 filter 过滤
<T> void	foreach(Collection<T> collection, java.util.function.Consumer<? super T> action)	遍历集合
static <M,K,T> T	getDataFromList(M searchData, java.util.function.Function<M,K> searchFunction, List<T> sourceList, java.util.function.Function<T,K> keyFunction)	根据 searchData 按照 searchFunction 规则从 sourceList 集合中搜索数据
static <T> T	getFirstItem(List<T> list)	获取 list 集合中的第一个元素
static <T> T	getLastItem(List<T> list)	获取 list 集合中的最后一个元素
static <S1,S2,K,R> List<R>	getListFromBaseList(List<S1> sourceList, java.util.function.Function<S1,K> sourceDataKeyFunction, List<S2> baseList, java.util.function.Function<S2,K> baseDataKeyFunction, java.util.function.BiFunction<S1,S2,R> function)	从 sourceList 和 baseList 集合中按照 sourceDataKeyFunction 和 baseDataKeyFunction 匹配对应的数据 按照 function 生成结果集合
static <S1,S2,K,R> List<R>	getListFromBaseList(List<S1> sourceList, java.util.function.Function<S1,R> resultFunction, java.util.function.Function<R,K> resultDataKeyFunction, List<S2> baseList, java.util.function.Function<S2,K> baseDataKeyFunction, java.util.function.BiConsumer<R,List<S2>> consumer)	从 sourceList 按照 resultFunction 生成结果集合 结果集合 List1 和 List2 按照 resultDataKeyFunction 和 baseDataKeyFunction 匹配对应的数据 匹配到的 List 按照 consumer 规则供结果集使用
static <K,S> Map<K,List<S>>	groupingBy(List<S> source, java.util.function.Function<? super S,? extends K> classifier)	将 list 集合分组
static <K,S> Map<K,List<S>>	groupingBy(List<S> source, java.util.function.Predicate<S> filter, java.util.function.Function<? super S,? extends K> classifier)	将过滤的 list 集合分组
static <K,T> Map<K,T>	handleMap(Map<K,T> map, java.util.function.BiConsumer<K,T> handlerMapper)	对原始 map 进行数据操作
static <K,V,R> List<R>	mapToList(Map<K,V> map, java.util.function.BiFunction<K,V,R> function)	遍历 map 元素并按照 function 转成 R 集合
static <K,V,R> List<R>	mapToList(Map<K,V> map, java.util.function.BiPredicate<K,V> predicate, java.util.function.BiFunction<K,V,R> function)	遍历 map 元素，先按照 predicate 过滤再按照 function 转成 R 集合
static <K,V,R> List<R>	mapValueToList(Map<K,V> map, java.util.function.Function<V,R> function)	从 map 中获取 value 集合并根据 function 转成 R 集合
static <T> List<T>	removeNull(List<? extends T> oldList)	去除 list 集合中的 null 元素进行
static <T> List<T>	sort(List<T> source, Comparator<T> comparator)	对 list 集合进行排序
static <T> List<T>	sort(List<T> source, Comparator<T> comparator, boolean reverse)	对 list 集合进行排序
static <S,T> List<T>	toList(List<S> source, java.util.function.Function<? super S,? extends T> mapper)	将原始的 list 按照 mapper 规则转成新的 list
static <S,T> List<T>	toList(List<S> source, java.util.function.Function<? super S,? extends T> mapper, boolean distinct)	将原始的 list 按照 mapper 规则转成新的 list
static <S,T> List<T>	toList(List<S> source, java.util.function.Predicate<S> filter, java.util.function.Function<? super S,? extends T> mapper)	将原始的 list 按照 filter 过滤之后，按照 mapper 规则转成新的 list
static <S,T> List<T>	toList(List<S> source, java.util.function.Predicate<S> filter, java.util.function.Function<? super S,? extends T> mapper, boolean distinct)	将原始的 list 按照 filter 过滤之后，按照 mapper 规则转成新的 list
static <S,T> List<T>	toList(S[] array, java.util.function.Function<? super S,? extends T> mapper)	将原始的 array 按照 mapper 规则转成新的 list
static <S,T> List<T>	toList(S[] source, java.util.function.Predicate<S> filter, java.util.function.Function<? super S,? extends T> mapper, boolean distinct)	将原始的 list 按照 filter 过滤之后，按照 mapper 规则转成新的 list
static <K,T,R> List<R>	toListByMap(Map<K,T> map, java.util.function.BiFunction<K,T,R> function)	从 map 中遍历生成 list
static <K,T,R> List<R>	toListByMap(Map<K,T> map, java.util.function.BiPredicate<K,T> filterMapMapper, java.util.function.BiFunction<K,T,R> function)	从过滤的 map 中遍历生成 list
static <S,T,K,V> List<T>	toListWithMap(List<S> source, Map<K,V> map, java.util.function.Function<S,K> keyFunction, java.util.function.BiFunction<S,V,T> mapContainKeyFunction)	list 遍历并匹配 map 中的元素，没有匹配到则丢弃
static <S,T,K,V> List<T>	toListWithMap(List<S> source, Map<K,V> map, java.util.function.Function<S,K> keyFunction, java.util.function.BiFunction<S,V,T> mapContainKeyFunction, java.util.function.Function<S,T> function)	list 遍历并匹配 map 中的元素，没有匹配到不丢弃
static <K,S,T> Map<K,T>	toMap(Collection<S> source, java.util.function.Function<? super S,? extends K> keyMapper, java.util.function.Function<? super S,? extends T> valueMapper, java.util.function.BinaryOperator<T> mergeFunction)	list 转 map 集合
static <K,S> Map<K,S>	toMap(List<S> source, java.util.function.Function<? super S,? extends K> keyMapper)	list 转 map 集合 map 的 value 为集合元素本身
static <K,S> Map<K,S>	toMap(List<S> source, java.util.function.Function<? super S,? extends K> keyMapper, java.util.function.BinaryOperator<S> mergeFunction)	list 转 map 集合 map 的 value 为集合元素本身
static <K,S,T> Map<K,T>	toMap(List<S> source, java.util.function.Function<? super S,? extends K> keyMapper, java.util.function.Function<? super S,? extends T> valueMapper)	list 转 map 集合
static <K,S> Map<K,S>	toMap(List<S> source, java.util.function.Predicate<S> predicate, java.util.function.Function<? super S,? extends K> keyMapper)	list 转 map 集合 map 的 value 为集合元素本身
static <K,S,T> Map<K,T>	toMap(List<S> source, java.util.function.Predicate<S> predicate, java.util.function.Function<? super S,? extends K> keyMapper, java.util.function.Function<? super S,? extends T> valueMapper)	list 转 map 集合
static <K,S> Map<K,S>	toMap(S[] source, java.util.function.Function<? super S,? extends K> keyMapper)	数组 转 map 集合 map 的 value 为集合元素本身
static <K,S> Map<K,S>	toMap(S[] source, java.util.function.Function<? super S,? extends K> keyMapper, java.util.function.BinaryOperator<S> mergeFunction)	数组 转 map 集合 map 的 value 为集合元素本身
static <K,S> Map<K,S>	toMapForSaveNew(Collection<S> source, java.util.function.Function<? super S,? extends K> keyMapper)	list 转 map 集合 map 的 value 为集合元素本身 如果出现 key 重复，则取前一个元素
static <K,S,T> Map<K,T>	toMapForSaveNew(List<S> source, java.util.function.Function<? super S,? extends K> keyMapper, java.util.function.Function<? super S,? extends T> valueMapper)	list 转 map 集合 如果出现 key 重复，则取前一个元素
static <K,S> Map<K,S>	toMapForSaveOld(List<S> source, java.util.function.Function<? super S,? extends K> keyMapper)	list 转 map 集合 map 的 value 为集合元素本身 如果出现 key 重复，则取前一个元素
static <K,S,T> Map<K,T>	toMapForSaveOld(List<S> source, java.util.function.Function<? super S,? extends K> keyMapper, java.util.function.Function<? super S,? extends T> valueMapper)	list 转 map 集合 如果出现 key 重复，则取前一个元素
static <S,T,K> Map<K,T>	toMapFromList(List<S> source, java.util.function.Function<? super S,? extends T> mapper, java.util.function.Function<? super T,? extends K> keyMapper)	将原始的 list 按照 mapper 规则转成新的 list 再按照新的 list 按照 keyMapper 为生成 key 规则转成 map 集合
static <S,T,K> Map<K,T>	toMapFromList(List<S> source, java.util.function.Predicate<S> predicate, java.util.function.Function<? super S,? extends T> mapper, java.util.function.Function<? super T,? extends K> keyMapper)	将原始的 list 按照 mapper 规则转成新的 list 再按照新的 list 按照 keyMapper 为生成 key 规则转成 map 集合
static <S,T> Set<T>	toSet(List<S> source, java.util.function.Function<? super S,? extends T> mapper)	list 转 set 集合

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

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

构造器详细资料

DataTool

public DataTool()

方法详细资料

toSet

public static <S,T> Set<T> toSet(List<S> source,
                                       java.util.function.Function<? super S,? extends T> mapper)

list 转 set 集合

类型参数:

S - 数据源集合中元素的类型

T - set 集合中元素的类型

参数:

source - 数据源集合

mapper - 按照源数据的 mapper 规则生成 set 元素

返回:

set 集合

toMap

public static <K,S,T> Map<K,T> toMap(List<S> source,
                                                       java.util.function.Function<? super S,? extends K> keyMapper,
                                                       java.util.function.Function<? super S,? extends T> valueMapper)

list 转 map 集合

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

T - map 集合中的 value 类型

参数:

source - 数据源集合

keyMapper - map 集合中的 key 获取规则

valueMapper - map 集合中的 value 获取规则

返回:

map 集合

toMap

public static <K,S,T> Map<K,T> toMap(List<S> source,
                                                       java.util.function.Predicate<S> predicate,
                                                       java.util.function.Function<? super S,? extends K> keyMapper,
                                                       java.util.function.Function<? super S,? extends T> valueMapper)

list 转 map 集合

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

T - map 集合中的 value 类型

参数:

source - 数据源集合

predicate - 过滤规则

keyMapper - map 集合中的 key 获取规则

valueMapper - map 集合中的 value 获取规则

返回:

map 集合

toMap

public static <K,S,T> Map<K,T> toMap(Collection<S> source,
                                                       java.util.function.Function<? super S,? extends K> keyMapper,
                                                       java.util.function.Function<? super S,? extends T> valueMapper,
                                                       java.util.function.BinaryOperator<T> mergeFunction)

list 转 map 集合

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

T - map 集合中的 value 类型

参数:

source - 数据源集合

keyMapper - map 集合中的 key 获取规则

valueMapper - map 集合中的 value 获取规则

mergeFunction - 存在相同 key 时取 value 的规则

返回:

map 集合

toMap

public static <K,S> Map<K,S> toMap(List<S> source,
                                               java.util.function.Function<? super S,? extends K> keyMapper)

list 转 map 集合 map 的 value 为集合元素本身

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

参数:

source - 数据源集合

keyMapper - map 集合中的 key 获取规则

返回:

map 集合

toMap

public static <K,S> Map<K,S> toMap(List<S> source,
                                               java.util.function.Predicate<S> predicate,
                                               java.util.function.Function<? super S,? extends K> keyMapper)

list 转 map 集合 map 的 value 为集合元素本身

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

参数:

source - 数据源集合

predicate - 过滤规则

keyMapper - map 集合中的 key 获取规则

返回:

map 集合

toMap

public static <K,S> Map<K,S> toMap(S[] source,
                                               java.util.function.Function<? super S,? extends K> keyMapper)

数组 转 map 集合 map 的 value 为集合元素本身

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

参数:

source - 数据源数组集合

keyMapper - map 集合中的 key 获取规则

返回:

map 集合

toMap

public static <K,S> Map<K,S> toMap(S[] source,
                                               java.util.function.Function<? super S,? extends K> keyMapper,
                                               java.util.function.BinaryOperator<S> mergeFunction)

数组 转 map 集合 map 的 value 为集合元素本身

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

参数:

source - 数据源数组集合

keyMapper - map 集合中的 key 获取规则

mergeFunction - 存在相同 key 时取 value 的规则

返回:

map 集合

toMap

public static <K,S> Map<K,S> toMap(List<S> source,
                                               java.util.function.Function<? super S,? extends K> keyMapper,
                                               java.util.function.BinaryOperator<S> mergeFunction)

list 转 map 集合 map 的 value 为集合元素本身

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

参数:

source - 数据源集合

keyMapper - map 集合中的 key 获取规则

mergeFunction - 存在相同 key 时取 value 的规则

返回:

map 集合

toMapFromList

public static <S,T,K> Map<K,T> toMapFromList(List<S> source,
                                                               java.util.function.Function<? super S,? extends T> mapper,
                                                               java.util.function.Function<? super T,? extends K> keyMapper)

将原始的 list 按照 mapper 规则转成新的 list 再按照新的 list 按照 keyMapper 为生成 key 规则转成 map 集合

类型参数:

S - 数据源集合中元素的类型

T - 目标数据的类型

K - map 集合中的 key 类型

参数:

source - 数据源集合

mapper - list 转 map 的规则

keyMapper - map 集合中的 key 获取规则

返回:

map 集合

toMapFromList

public static <S,T,K> Map<K,T> toMapFromList(List<S> source,
                                                               java.util.function.Predicate<S> predicate,
                                                               java.util.function.Function<? super S,? extends T> mapper,
                                                               java.util.function.Function<? super T,? extends K> keyMapper)

将原始的 list 按照 mapper 规则转成新的 list 再按照新的 list 按照 keyMapper 为生成 key 规则转成 map 集合

类型参数:

S - 数据源集合中元素的类型

T - 目标数据的类型

K - map 集合中的 key 类型

参数:

source - 数据源集合

predicate - 过滤规则

mapper - list 转 map 的规则

keyMapper - 数据源集合中元素的类型

返回:

map 集合

toMapForSaveOld

public static <K,S> Map<K,S> toMapForSaveOld(List<S> source,
                                                         java.util.function.Function<? super S,? extends K> keyMapper)

list 转 map 集合 map 的 value 为集合元素本身 如果出现 key 重复，则取前一个元素

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

参数:

source - 数据源集合

keyMapper - map 集合中的 key 获取规则

返回:

map 集合

toMapForSaveOld

public static <K,S,T> Map<K,T> toMapForSaveOld(List<S> source,
                                                                 java.util.function.Function<? super S,? extends K> keyMapper,
                                                                 java.util.function.Function<? super S,? extends T> valueMapper)

list 转 map 集合 如果出现 key 重复，则取前一个元素

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

T - map 集合中的 value 类型

参数:

source - 数据源集合

keyMapper - map 集合中的 key 获取规则

valueMapper - map 集合中的 value 获取规则

返回:

map 集合

toMapForSaveNew

public static <K,S> Map<K,S> toMapForSaveNew(Collection<S> source,
                                                         java.util.function.Function<? super S,? extends K> keyMapper)

list 转 map 集合 map 的 value 为集合元素本身 如果出现 key 重复，则取前一个元素

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

参数:

source - 数据源集合

keyMapper - map 集合中的 key 获取规则

返回:

map 集合

toMapForSaveNew

public static <K,S,T> Map<K,T> toMapForSaveNew(List<S> source,
                                                                 java.util.function.Function<? super S,? extends K> keyMapper,
                                                                 java.util.function.Function<? super S,? extends T> valueMapper)

list 转 map 集合 如果出现 key 重复，则取前一个元素

类型参数:

K - map 集合中的 key 类型

S - 数据源集合中元素的类型

T - map 集合中的 value 类型

参数:

source - 数据源集合

keyMapper - map 集合中的 key 获取规则

valueMapper - map 集合中的 value 获取规则

返回:

map 集合

toList

public static <S,T> List<T> toList(List<S> source,
                                         java.util.function.Function<? super S,? extends T> mapper)

将原始的 list 按照 mapper 规则转成新的 list

类型参数:

S - 源数据类型

T - 目标数据类型

参数:

source - 源数据集合

mapper - 生成新的 list 接口规则

返回:

list

toList

public static <S,T> List<T> toList(S[] array,
                                         java.util.function.Function<? super S,? extends T> mapper)

将原始的 array 按照 mapper 规则转成新的 list

类型参数:

S - 源数据类型

T - 目标数据类型

参数:

array - 源数据数组

mapper - 生成新的 list 接口规则

返回:

list

toList

public static <S,T> List<T> toList(List<S> source,
                                         java.util.function.Function<? super S,? extends T> mapper,
                                         boolean distinct)

将原始的 list 按照 mapper 规则转成新的 list

类型参数:

S - 源数据类型

T - 目标数据类型

参数:

source - 源数据集合

mapper - 生成新的 list 接口规则

distinct - 是否去重

返回:

list

toListWithMap

public static <S,T,K,V> List<T> toListWithMap(List<S> source,
                                                                Map<K,V> map,
                                                                java.util.function.Function<S,K> keyFunction,
                                                                java.util.function.BiFunction<S,V,T> mapContainKeyFunction)

list 遍历并匹配 map 中的元素，没有匹配到则丢弃

类型参数:

S - 源数据集合元素类型

T - 目标数据集合元素类型

K - map 集合的 key 类型

V - map 集合的 value 类型

参数:

source - 源数据集合

map - mpa 集合

keyFunction - 生成 key 的接口

mapContainKeyFunction - 生成 list 的接口

返回:

list

toListWithMap

public static <S,T,K,V> List<T> toListWithMap(List<S> source,
                                                                Map<K,V> map,
                                                                java.util.function.Function<S,K> keyFunction,
                                                                java.util.function.BiFunction<S,V,T> mapContainKeyFunction,
                                                                java.util.function.Function<S,T> function)

list 遍历并匹配 map 中的元素，没有匹配到不丢弃

类型参数:

S - 源数据集合元素类型

T - 目标数据集合元素类型

K - map 集合的 key 类型

V - map 集合的 value 类型

参数:

source - 源数据集合

map - mpa 集合

keyFunction - 生成 key 的接口

mapContainKeyFunction - 生成 list 的接口

function - 生成 list 的接口

返回:

list

toList

public static <S,T> List<T> toList(List<S> source,
                                         java.util.function.Predicate<S> filter,
                                         java.util.function.Function<? super S,? extends T> mapper,
                                         boolean distinct)

将原始的 list 按照 filter 过滤之后，按照 mapper 规则转成新的 list

类型参数:

S - 源数据类型

T - 目标数据类型

参数:

source - 源数据集合

filter - 源数据集合过滤规则

mapper - 生成新的 list 接口规则

distinct - 是否去重 distinct 为 true，表示过滤之后生成list之前进行去重操作

返回:

list

toList

public static <S,T> List<T> toList(S[] source,
                                         java.util.function.Predicate<S> filter,
                                         java.util.function.Function<? super S,? extends T> mapper,
                                         boolean distinct)

将原始的 list 按照 filter 过滤之后，按照 mapper 规则转成新的 list

类型参数:

S - 源数据类型

T - 目标数据类型

参数:

source - 源数据数组

filter - 源数据集合过滤规则

mapper - 生成新的 list 接口规则

distinct - 是否去重 distinct 为 true，表示过滤之后生成list之前进行去重操作

返回:

list

toList

public static <S,T> List<T> toList(List<S> source,
                                         java.util.function.Predicate<S> filter,
                                         java.util.function.Function<? super S,? extends T> mapper)

将原始的 list 按照 filter 过滤之后，按照 mapper 规则转成新的 list

类型参数:

S - 源数据类型

T - 目标数据类型

参数:

source - 源数据集合

filter - 源数据集合过滤规则

mapper - 生成新的 list 接口规则

返回:

list

toListByMap

public static <K,T,R> List<R> toListByMap(Map<K,T> map,
                                                      java.util.function.BiFunction<K,T,R> function)

从 map 中遍历生成 list

类型参数:

K - map 集合的 key 类型

T - map 集合的数据类型

R - 目标数据类型

参数:

map - 源数据 map 集合

function - 生成 list 规则

返回:

list

toListByMap

public static <K,T,R> List<R> toListByMap(Map<K,T> map,
                                                      java.util.function.BiPredicate<K,T> filterMapMapper,
                                                      java.util.function.BiFunction<K,T,R> function)

从过滤的 map 中遍历生成 list

类型参数:

K - map 集合的 key 类型

T - map 集合的数据类型

R - 目标数据类型

参数:

map - 源数据 map 集合

filterMapMapper - 过滤 map 的接口规则

function - 生成 list 规则

返回:

list

groupingBy

public static <K,S> Map<K,List<S>> groupingBy(List<S> source,
                                                          java.util.function.Function<? super S,? extends K> classifier)

将 list 集合分组

类型参数:

K - map 集合中的 key 类型

S - map 集合中的 value 类型

参数:

source - 数据源集合

classifier - 分组规则

返回:

list

enumGroupingBy

public static <K,S extends Enum<S>> Map<K,List<S>> enumGroupingBy(Class<S> sourceEnumClass,
                                                                              java.util.function.Function<? super S,? extends K> classifier)

将 枚举分组 集合分组

类型参数:

K - map 集合中的 key 类型

S - map 集合中的 value 集合元素类型

参数:

sourceEnumClass - 枚举class类

classifier - 分组规则

返回:

list

groupingBy

public static <K,S> Map<K,List<S>> groupingBy(List<S> source,
                                                          java.util.function.Predicate<S> filter,
                                                          java.util.function.Function<? super S,? extends K> classifier)

将过滤的 list 集合分组

类型参数:

K - map 集合中的 key 类型

S - map 集合中的 value 类型

参数:

source - 数据源集合

filter - 过滤源数据集合的接口规则

classifier - 分组规则

返回:

list

sort

public static <T> List<T> sort(List<T> source,
                               Comparator<T> comparator)

对 list 集合进行排序

类型参数:

T - 集合的数据类型

参数:

source - 数据源集合

comparator - 排序器

返回:

list

sort

public static <T> List<T> sort(List<T> source,
                               Comparator<T> comparator,
                               boolean reverse)

对 list 集合进行排序

类型参数:

T - 集合的数据类型

参数:

source - 数据源集合

comparator - 排序器

reverse - 是否逆序

返回:

list

deduplicate

public static <K,T> DeduplicateResult<K,T> deduplicate(List<T> source,
                                                                   java.util.function.Function<T,Boolean> isValidFunction,
                                                                   java.util.function.Function<T,K> getDeduplicatedKeyFunction)

对集合数据进行去重器, 默认保留最后出现的重复元素 非线程安全

类型参数:

K - 去重属性的类型

T - 数据源集合中元素的类型

参数:

source - 数据源集合

isValidFunction - 数据是否有效

getDeduplicatedKeyFunction - 获取去重的数据值

返回:

DeduplicateResult

deduplicate

public static <K,T> DeduplicateResult<K,T> deduplicate(List<T> source,
                                                                   java.util.function.Function<T,K> getDeduplicatedKeyFunction)

对集合数据进行去重器, 默认保留最后出现的重复元素 非线程安全

类型参数:

K - 去重属性的类型

T - 数据源集合中元素的类型

参数:

source - 数据源集合

getDeduplicatedKeyFunction - 获取去重的数据值

返回:

DeduplicateResult

deduplicate

public static <K,T> DeduplicateResult<K,T> deduplicate(List<T> source,
                                                                   java.util.function.Function<T,K> getDeduplicatedKeyFunction,
                                                                   boolean remainFirst)

对集合数据进行去重器 非线程安全

类型参数:

K - 去重属性的类型

T - 数据源集合中元素的类型

参数:

source - 数据源集合

getDeduplicatedKeyFunction - 获取去重的数据值

remainFirst - 是否保留第一次出现的重复值

返回:

DeduplicateResult

deduplicate

public static <K,T> DeduplicateResult<K,T> deduplicate(List<T> source,
                                                                   java.util.function.Function<T,Boolean> isValidFunction,
                                                                   java.util.function.Function<T,K> getDeduplicatedKeyFunction,
                                                                   boolean remainFirst)

对集合数据进行去重器 非线程安全

类型参数:

K - 去重属性的类型

T - 数据源集合中元素的类型

参数:

source - 数据源集合

isValidFunction - 数据是否有效

getDeduplicatedKeyFunction - 获取去重的数据值

remainFirst - 是否保留第一次出现的重复值

返回:

DeduplicateResult

enumMap

public static <K,T extends Enum<T>> Map<K,T> enumMap(Class<T> sourceEnumClass,
                                                                 java.util.function.Function<T,K> keyMapper)

枚举转 map 集合

类型参数:

K - map 集合中的 key 类型

T - 枚举类型 map 集合中的 value 类型

参数:

sourceEnumClass - 数据源枚举 Class类

keyMapper - map 集合中的 key 获取规则

返回:

map 集合

enumMap

public static <K,V,T extends Enum<T>> Map<K,V> enumMap(Class<T> sourceEnumClass,
                                                                         java.util.function.Function<T,K> keyMapper,
                                                                         java.util.function.Function<T,V> valueMapper)

枚举转 map 集合

类型参数:

K - map 集合中的 key 类型

V - map 集合中的 value 类型

T - 枚举类型

参数:

sourceEnumClass - 数据源枚举 Class类

keyMapper - map 集合中的 key 获取规则

valueMapper - map 集合中的 value 获取规则

返回:

map 集合

enumMap

public static <T extends Enum<T>> Map<String,T> enumMap(Class<T> sourceEnumClass)

枚举转 map 集合 map 集合中的 key 为 Enum 的 name() 方法返回值

类型参数:

T - map 集合中的 value 类型

参数:

sourceEnumClass - 数据源枚举 Class类

返回:

map 集合

enumList

public static <T extends Enum<T>,R> List<R> enumList(Class<T> sourceEnumClass,
                                                           java.util.function.Function<T,R> function)

枚举转 list 集合 按照 function 将枚举转成 list 集合

类型参数:

T - 枚举类型

R - 结果集类型

参数:

sourceEnumClass - 数据源枚举 Class类

function - 生成接口

返回:

list

enumContainsKey

public static <K,T extends Enum<T>> boolean enumContainsKey(K key,
                                                                  Class<T> sourceEnumClass,
                                                                  java.util.function.Function<T,K> keyMapper)

判断 key 是否存在于枚举转 map 的集合中

类型参数:

K - map 集合中的 key 类型

T - map 集合中的 value 类型

参数:

key - 要判断的 key

sourceEnumClass - 数据源枚举 Class类

keyMapper - map 集合中的 key 获取规则

返回:

map

enumGetValue

public static <K,T extends Enum<T>> T enumGetValue(K key,
                                                         Class<T> sourceEnumClass,
                                                         java.util.function.Function<T,K> keyMapper)

根据 key 获取对应的枚举实例

类型参数:

K - map 集合中的 key 类型

T - map 集合中的 value 类型

参数:

key - 要获取枚举实例的 key

sourceEnumClass - 数据源枚举 Class类

keyMapper - map 集合中的 key 获取规则

返回:

枚举实例

filter

public static <T> List<T> filter(List<T> source,
                                 java.util.function.Predicate<? super T> filter)

将原始的 list 按照 filter 过滤

类型参数:

T - 数据类型

参数:

source - 数据原始集合

filter - 过滤规则

返回:

list

filter

public static <T> List<T> filter(T[] source,
                                 java.util.function.Predicate<? super T> filter)

将原始的 list 按照 filter 过滤

类型参数:

T - 数据类型

参数:

source - 数据原始数组

filter - 过滤规则

返回:

list

getDataFromList

public static <M,K,T> T getDataFromList(M searchData,
                                                    java.util.function.Function<M,K> searchFunction,
                                                    List<T> sourceList,
                                                    java.util.function.Function<T,K> keyFunction)

根据 searchData 按照 searchFunction 规则从 sourceList 集合中搜索数据

类型参数:

M - 要搜索的源数据类型

K - 搜索的 key 类型

T - 被搜索的数据源类型

参数:

searchData - 要搜索的源数据

searchFunction - 搜索的key

sourceList - 被搜索的数据源

keyFunction - 被搜索的数据源索引生成规则

返回:

被搜索的数据源

handleMap

public static <K,T> Map<K,T> handleMap(Map<K,T> map,
                                                   java.util.function.BiConsumer<K,T> handlerMapper)

对原始 map 进行数据操作

类型参数:

K - map 集合的 key 数据类型

T - map 集合的 value 数据类型

参数:

map - 源 map 集合

handlerMapper - 集合元素处理接口规则

返回:

返回原始 map 集合

removeNull

public static <T> List<T> removeNull(List<? extends T> oldList)

去除 list 集合中的 null 元素进行

类型参数:

T - 原始数据类型

参数:

oldList - 原始数据集合

返回:

list

mapValueToList

public static <K,V,R> List<R> mapValueToList(Map<K,V> map,
                                                         java.util.function.Function<V,R> function)

从 map 中获取 value 集合并根据 function 转成 R 集合

类型参数:

K - key 类型

V - value 类型

R - 目标数据类型

参数:

map - 原始数据源集合

function - 映射接口

返回:

list

mapToList

public static <K,V,R> List<R> mapToList(Map<K,V> map,
                                                    java.util.function.BiFunction<K,V,R> function)

遍历 map 元素并按照 function 转成 R 集合

类型参数:

K - key 类型

V - key 类型

R - 结果集类型

参数:

map - 原始数据源集合

function - 映射接口

返回:

list

mapToList

public static <K,V,R> List<R> mapToList(Map<K,V> map,
                                                    java.util.function.BiPredicate<K,V> predicate,
                                                    java.util.function.BiFunction<K,V,R> function)

遍历 map 元素，先按照 predicate 过滤再按照 function 转成 R 集合

类型参数:

K - key 类型

V - key 类型

R - 结果集类型

参数:

map - 原始数据源集合

predicate - 过滤接口

function - 映射接口

返回:

list

getListFromBaseList

public static <S1,S2,K,R> List<R> getListFromBaseList(List<S1> sourceList,
                                                                        java.util.function.Function<S1,K> sourceDataKeyFunction,
                                                                        List<S2> baseList,
                                                                        java.util.function.Function<S2,K> baseDataKeyFunction,
                                                                        java.util.function.BiFunction<S1,S2,R> function)

从 sourceList 和 baseList 集合中按照 sourceDataKeyFunction 和 baseDataKeyFunction 匹配对应的数据 按照 function 生成结果集合

类型参数:

S1 - 原始集合数据类型

S2 - 基础集合数据类型

K - key 的数据类型

R - 结果集数据类型

参数:

sourceList - 原始集合

sourceDataKeyFunction - 生成 key 规则

baseList - 基础集合

baseDataKeyFunction - 生成 key 规则

function - 生成结果规则

返回:

list

getListFromBaseList

public static <S1,S2,K,R> List<R> getListFromBaseList(List<S1> sourceList,
                                                                        java.util.function.Function<S1,R> resultFunction,
                                                                        java.util.function.Function<R,K> resultDataKeyFunction,
                                                                        List<S2> baseList,
                                                                        java.util.function.Function<S2,K> baseDataKeyFunction,
                                                                        java.util.function.BiConsumer<R,List<S2>> consumer)

从 sourceList 按照 resultFunction 生成结果集合 结果集合 List1 和 List2 按照 resultDataKeyFunction 和 baseDataKeyFunction 匹配对应的数据 匹配到的 List 按照 consumer 规则供结果集使用

类型参数:

S1 - 原始集合数据类型

S2 - 基础集合数据类型

K - key 的数据类型

R - 结果集数据类型

参数:

sourceList - 原始集合

resultFunction - 结果集生成规则

resultDataKeyFunction - 生成 key 规则

baseList - 基础集合数据类型

baseDataKeyFunction - 生成 key 规则

consumer - 匹配到的基础数据集合供结果数据使用

返回:

list

getFirstItem

public static <T> T getFirstItem(List<T> list)

获取 list 集合中的第一个元素

类型参数:

T - 集合元素的泛型

参数:

list - list 集合

返回:

集合元素

getLastItem

public static <T> T getLastItem(List<T> list)

获取 list 集合中的最后一个元素

类型参数:

T - 集合元素的泛型

参数:

list - list 集合

返回:

集合元素

foreach

public <T> void foreach(Collection<T> collection,
                        java.util.function.Consumer<? super T> action)

遍历集合

类型参数:

T - 集合元素的类型

参数:

collection - 集合

action - 遍历规则