模块 develop.toolkit.base

程序包 develop.toolkit.base.utils

类 CollectionAdvice

java.lang.Object

develop.toolkit.base.utils.CollectionAdvice

public final class CollectionAdvice
extends Object

集合增强工具

作者:

qiushui on 2018-12-20.

构造器概要

构造器

构造器	说明
CollectionAdvice()

方法概要

修饰符和类型	方法	说明
static <E> boolean	allAccept(Collection<E> collection, Function<E,?> function)	判断所有元素的处理值相等
static <E> boolean	allMatch(Collection<E> collection, Predicate<E> predicate)	全部匹配
static <E> boolean	anyMatch(Collection<E> collection, Predicate<E> predicate)	任意一个匹配
static <E,T> CollectionInMap<E,T>	associate(Collection<E> master, Collection<T> target, BiPredicate<E,T> predicate)	关联 将集合target按条件与集合master配对
static <E,T> KeyValuePairs<E,T>	associateOne(Collection<E> master, Collection<T> target, BiPredicate<E,T> predicate)	关联 （明确是单个的） 将集合target按条件与集合master配对
static <E> Set<E>	complementary(Collection<E> master, Collection<E> other)	补集
static <E> boolean	contains(Collection<E> collection, Object target, Function<E,?> function)	检查元素
static <E> List<E>	getAllMatch(Collection<E> collection, Object target, Function<E,?> function)	获得全部匹配的元素
static <E> Optional<E>	getFirstFalse(Collection<E> collection, Predicate<E> predicate)	获得第一个判断是false的元素
static <E> Optional<E>	getFirstMatch(Collection<E> collection, Object target)	获得第一个匹配的元素
static <E> Optional<E>	getFirstMatch(Collection<E> collection, Object target, Function<E,?> function)	获得第一个匹配的元素
static <E> Optional<E>	getFirstTrue(Collection<E> collection, Predicate<E> predicate)	获得第一个判断是true的元素
static <E,K,V> CollectionInMap<K,V>	grouping(Collection<E> collection, Function<E,K> keySupplier, Function<E,V> valueSupplier)	分组
static <K,V> CollectionInMap<K,V>	grouping(Collection<V> collection, Function<V,K> keySupplier)
static <E,K> Counter<K>	groupingCount(Collection<E> collection, Function<E,K> keySupplier)	分组求数量
static <K,V> Map<K,V>	groupingUniqueKey(Collection<V> collection, Function<V,K> keySupplier)
static <E> Set<E>	intersection(Collection<E> master, Collection<E>... other)	交集
static <E> Collection<E>	merge(Supplier<Collection<E>> supplier, Collection<E>... collections)	合并多集合
static <T> void	pagingProcess(List<T> list, int size, Consumer<List<T>> consumer)	分页处理
static <E> TwoValues<List<E>,List<E>>	partition(Collection<E> collection, Predicate<E> predicate)	划分 按条件把集合拆分成满足条件和不满足条件的两个集合
static <T,S> List<T>	sort(Collection<T> master, Collection<S> sortTarget, BiPredicate<T,S> predicate)	指定排序 把master的元素值按sortTarget的元素值排序，条件按predicate
static <T,S> List<T>	sort(Collection<T> master, S[] sortTarget, BiPredicate<T,S> predicate)
static <E> Set<E>	union(Collection<E> master, Collection<E>... other)	并集
static <E> List<TwoValues<E,E>>	zip(List<E> master, List<E> other)	压缩 将两个集合的元素按索引捆绑到一起

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

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

构造器详细资料

CollectionAdvice

public CollectionAdvice()

方法详细资料

contains

public static <E> boolean contains(Collection<E> collection,
                                   Object target,
                                   Function<E,?> function)

检查元素

getFirstMatch

public static <E> Optional<E> getFirstMatch(Collection<E> collection,
                                            Object target,
                                            Function<E,?> function)

获得第一个匹配的元素

getFirstMatch

public static <E> Optional<E> getFirstMatch(Collection<E> collection,
                                            Object target)

获得第一个匹配的元素

getFirstTrue

public static <E> Optional<E> getFirstTrue(Collection<E> collection,
                                           Predicate<E> predicate)

获得第一个判断是true的元素

getFirstFalse

public static <E> Optional<E> getFirstFalse(Collection<E> collection,
                                            Predicate<E> predicate)

获得第一个判断是false的元素

getAllMatch

public static <E> List<E> getAllMatch(Collection<E> collection,
                                      Object target,
                                      Function<E,?> function)

获得全部匹配的元素

allMatch

public static <E> boolean allMatch(Collection<E> collection,
                                   Predicate<E> predicate)

全部匹配

anyMatch

public static <E> boolean anyMatch(Collection<E> collection,
                                   Predicate<E> predicate)

任意一个匹配

allAccept

public static <E> boolean allAccept(Collection<E> collection,
                                    Function<E,?> function)

判断所有元素的处理值相等

grouping

public static <E,K,V> CollectionInMap<K,V> grouping(Collection<E> collection,
                                                                      Function<E,K> keySupplier,
                                                                      Function<E,V> valueSupplier)

分组

grouping

public static <K,V> CollectionInMap<K,V> grouping(Collection<V> collection,
                                                              Function<V,K> keySupplier)

groupingUniqueKey

public static <K,V> Map<K,V> groupingUniqueKey(Collection<V> collection,
                                                           Function<V,K> keySupplier)

groupingCount

public static <E,K> Counter<K> groupingCount(Collection<E> collection,
                                                   Function<E,K> keySupplier)

分组求数量

union

@SafeVarargs
public static <E> Set<E> union(Collection<E> master,
                               Collection<E>... other)

并集

intersection

@SafeVarargs
public static <E> Set<E> intersection(Collection<E> master,
                                      Collection<E>... other)

交集

complementary

public static <E> Set<E> complementary(Collection<E> master,
                                       Collection<E> other)

补集

merge

@SafeVarargs
public static <E> Collection<E> merge(Supplier<Collection<E>> supplier,
                                      Collection<E>... collections)

合并多集合

associate

public static <E,T> CollectionInMap<E,T> associate(Collection<E> master,
                                                               Collection<T> target,
                                                               BiPredicate<E,T> predicate)

关联 将集合target按条件与集合master配对

associateOne

public static <E,T> KeyValuePairs<E,T> associateOne(Collection<E> master,
                                                                Collection<T> target,
                                                                BiPredicate<E,T> predicate)

关联 （明确是单个的） 将集合target按条件与集合master配对

partition

public static <E> TwoValues<List<E>,List<E>> partition(Collection<E> collection,
                                                             Predicate<E> predicate)

划分 按条件把集合拆分成满足条件和不满足条件的两个集合

zip

public static <E> List<TwoValues<E,E>> zip(List<E> master,
                                                 List<E> other)

压缩 将两个集合的元素按索引捆绑到一起

pagingProcess

public static <T> void pagingProcess(List<T> list,
                                     int size,
                                     Consumer<List<T>> consumer)

分页处理

sort

public static <T,S> List<T> sort(Collection<T> master,
                                       Collection<S> sortTarget,
                                       BiPredicate<T,S> predicate)

指定排序 把master的元素值按sortTarget的元素值排序，条件按predicate

sort

public static <T,S> List<T> sort(Collection<T> master,
                                       S[] sortTarget,
                                       BiPredicate<T,S> predicate)