Package org.aoju.bus.core.toolkit
Class CollKit
java.lang.Object
org.aoju.bus.core.toolkit.CollKit
-
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionstatic interface针对一个参数做相应的操作static interfaceHash计算接口static interface针对两个参数做相应的操作,例如Map中的KEY和VALUE -
Constructor Summary
Constructors -
Method Summary
Modifier and TypeMethodDescriptionstatic <T> Collection<T> addAll(Collection<T> collection, Iterable<T> iterable) 加入全部static <T> Collection<T> addAll(Collection<T> collection, Object value) 将指定对象全部加入到集合中 提供的对象如果为集合类型,会自动转换为目标元素类型static <T> Collection<T> addAll(Collection<T> collection, Object value, Type elementType) 将指定对象全部加入到集合中 提供的对象如果为集合类型,会自动转换为目标元素类型static <T> Collection<T> addAll(Collection<T> collection, Enumeration<T> enumeration) 加入全部static <T> Collection<T> addAll(Collection<T> collection, Iterator<T> iterator) 加入全部static <T> Collection<T> addAll(Collection<T> collection, T[] values) 加入全部将字符串加入List中static <T> List<T> addAllIfNotContains(List<T> list, List<T> otherList) 将另一个列表中的元素加入到列表中,如果列表中已经存在此元素则忽略之static <T,S extends T>
booleanaddIfAbsent(Collection<T> collection, S object) 一个对象不为空且不存在于该集合中时,加入到该集合中static <E> Enumeration<E> asEnumeration(Iterator<E> iter) Iterator转换为Enumerationstatic <E> Iterable<E> asIterable(Iterator<E> iter) static <E> Iterator<E> asIterator(Enumeration<E> e) Enumeration转换为Iteratorstatic voidclear(Collection<?>... collections) 清除一个或多个集合内的元素,每个集合调用clear()方法static <T> T[]Concatenates 2 arraysstatic booleancontains(Collection<?> collection, Object value) 判断指定集合是否包含指定值,如果集合为空(null或者空),返回false,否则找到元素返回truestatic <T> booleancontains(Collection<T> collection, Predicate<? super T> containFunc) 自定义函数判断集合是否包含某类值static booleancontains(Enumeration<?> enumeration, Object element) 检查给定枚举是否包含给定元素.static boolean检查给定的迭代器是否包含给定的元素.static <T> booleancontains(T[] array, T element) 检查给定数组是否包含给定元素static booleancontainsAll(Collection<?> coll1, Collection<?> coll2) 集合1中是否包含集合2中所有的元素,即集合2是否为集合1的子集static booleancontainsAny(Collection<?> coll1, Collection<?> coll2) 其中一个集合在另一个集合中是否至少包含一个元素,既是两个集合是否至少有一个共同的元素static <T> int集合中匹配规则的数量根据集合返回一个元素计数的Map所谓元素计数就是假如这个集合中某个元素出现了n次,那将这个元素做为key,n做为value 例如:[a,b,c,c,c] 得到: a: 1 b: 1 c: 3static <T> Collection<T> 创建新的集合对象,返回具体的泛型集合static <T> Collection<T> 创建新的集合对象,返回具体的泛型集合static <K,V> Map <K, V> static <T extends Collection<E>,E>
TdefaultIfEmpty(T collection, Supplier<? extends T> supplier) 如果给定集合为空,返回默认集合static <T extends Collection<E>,E>
TdefaultIfEmpty(T collection, T defaultCollection) 如果给定集合为空,返回默认集合static <T> Collection<T> disjunction(Collection<T> coll1, Collection<T> coll2) 两个集合的差集 针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留两个集合中此元素个数差的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[c],此结果中只保留了一个 任意一个集合为空,返回另一个集合 两个集合无交集则返回两个集合的组合static <T> List<T> distinct(Collection<T> collection) 去重集合static <T,K> List <T> distinct(Collection<T> collection, Function<T, K> uniqueGenerator, boolean override) 根据函数生成的KEY去重集合,如根据Bean的某个或者某些字段完成去重 去重可选是保留最先加入的值还是后加入的值static <T> Predicate<T> 去重集合static <T> List<T> empty()获取一个空List,这个空List不可变static <T> List<T> emptyIfNull(List<T> list) 如果提供的集合为null,返回一个不可变的默认空集合,否则返回原集合 空集合使用Collections.emptyList()static <T> Set<T> emptyIfNull(Set<T> set) 如果提供的集合为null,返回一个不可变的默认空集合,否则返回原集合 空集合使用Collections.emptySet()通过Editor抽取集合元素中的某些值返回为新列表 例如提供的是一个Bean列表,通过Editor接口实现获取某个字段值,返回这个字段值组成的新列表通过Editor抽取集合元素中的某些值返回为新列表 例如提供的是一个Bean列表,通过Editor接口实现获取某个字段值,返回这个字段值组成的新列表static <T> Collection<T> filter(Collection<T> collection, Editor<T> editor) 过滤 过滤过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能:static <E> Iterator<E> 过滤集合,此方法在原集合上直接修改 通过实现Filter接口,完成元素的过滤,这个Filter实现可以实现以下功能:static <T> List<T> 过滤 过滤过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能:static <T extends Iterable<E>,E>
T过滤集合,此方法在原集合上直接修改 通过实现Filter接口,完成元素的过滤,这个Filter实现可以实现以下功能:static <T> T查找第一个匹配元素对象static <T> TfindOneByField(Iterable<T> collection, String fieldName, Object fieldValue) 查找第一个匹配元素对象 如果集合元素是Map,则比对键和值是否相同,相同则返回 如果为普通Bean,则通过反射比对元素字段名对应的字段值是否相同,相同则返回 如果给定字段值参数是null且元素对象中的字段值也为null则认为相同static <T> Optional<T> firstNotNullElem(Collection<T> list) 找到第一个不为 null 的元素static ObjectforceGetFieldValue(Object object, String fieldName) 获取指定对象的指定属性值(去除private,protected的限制)static <T> voidforEach(Enumeration<T> enumeration, CollKit.Consumer<T> consumer) 循环遍历Enumeration,使用CollKit.Consumer接受遍历的每条数据,并针对每条数据做处理static <T> voidforEach(Iterator<T> iterator, CollKit.Consumer<T> consumer) 循环遍历Iterator,使用CollKit.Consumer接受遍历的每条数据,并针对每条数据做处理static <K,V> void forEach(Map<K, V> map, CollKit.KVConsumer<K, V> kvConsumer) 循环遍历Map,使用CollKit.KVConsumer接受遍历的每条数据,并针对每条数据做处理static <T> Tget(Collection<T> collection, int index) 获取集合中指定下标的元素值,下标可以为负数,例如-1表示最后一个元素 如果元素越界,返回nullstatic <T> List<T> getAny(Collection<T> collection, int... indexes) 获取集合中指定多个下标的元素值,下标可以为负数,例如-1表示最后一个元素getFieldValues(Iterable<?> collection, String fieldName) 获取给定Bean列表中指定字段名对应字段值的列表 列表元素支持Bean与Mapstatic <T> T获取集合的第一个元素static <T> T获取集合的第一个元素static <T> TgetLast(Collection<T> collection) 获取集合的最后一个元素group(Collection<T> collection, CollKit.Hash<T> hash) 分组,按照CollKit.Hash接口定义的hash算法,集合中的元素放入hash值对应的子列表中group2Map(Collection<E> collection, Function<E, T> key1, Function<E, U> key2) 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层mapCollection<E> ---> Map<T,Map<U,E>>group2Map(Collection<E> collection, Function<E, T> key1, Function<E, U> key2, boolean isParallel) 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层mapCollection<E> ---> Map<T,Map<U,E>>groupBy2Key(Collection<E> collection, Function<E, K> key1, Function<E, U> key2) 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层mapCollection<E> ---> Map<T,Map<U,List<E>>>groupBy2Key(Collection<E> collection, Function<E, K> key1, Function<E, U> key2, boolean isParallel) 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层mapCollection<E> ---> Map<T,Map<U,List<E>>>groupByField(Collection<T> collection, String fieldName) 根据元素的指定字段名分组,非Bean都放在第一个分组中groupByKey(Collection<E> collection, Function<E, K> key) 将collection按照规则(比如有相同的班级id)分类成mapCollection<E> -------> Map<K,List<E>>groupByKey(Collection<E> collection, Function<E, K> key, boolean isParallel) 将collection按照规则(比如有相同的班级id)分类成mapCollection<E> -------> Map<K,List<E>>groupingBy(Function<? super T, ? extends K> classifier) 提供对null值友好的groupingBy操作的Collector实现groupingBy(Function<? super T, ? extends K> classifier, Function<? super T, ? extends R> valueMapper) 提供对null值友好的groupingBy操作的Collector实现, 对集合分组,然后对分组后的值集合进行映射static <T,K, R, C extends Collection<R>>
Collector<T, ?, Map<K, C>> groupingBy(Function<? super T, ? extends K> classifier, Function<? super T, ? extends R> valueMapper, Supplier<C> valueCollFactory) 提供对null值友好的groupingBy操作的Collector实现, 对集合分组,然后对分组后的值集合进行映射static <T,K, R, C extends Collection<R>, M extends Map<K, C>>
Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier, Function<? super T, ? extends R> valueMapper, Supplier<C> valueCollFactory, Supplier<M> mapFactory) 提供对null值友好的groupingBy操作的Collector实现, 对集合分组,然后对分组后的值集合进行映射groupingBy(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream) 提供对null值友好的groupingBy操作的Collector实现,可指定map类型groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream) 提供对null值友好的groupingBy操作的Collector实现groupKeyValue(Collection<E> collection, Function<E, K> key, Function<E, V> value) 将collection按照规则(比如有相同的班级id)分类成map,map中的key为班级id,value为班级名Collection<E> -------> Map<K,List<V>>groupKeyValue(Collection<E> collection, Function<E, K> key, Function<E, V> value, boolean isParallel) 将collection按照规则(比如有相同的班级id)分类成map,map中的key为班级id,value为班级名Collection<E> -------> Map<K,List<V>>static boolean是否包含null元素static <T> intindexOf(Collection<T> collection, Predicate<T> predicate) 获取匹配规则定义中匹配到元素的第一个位置 此方法对于某些无序集合的位置信息,以转换为数组后的位置为准static <T> int[]indexOfAll(Collection<T> collection, Predicate<? super T> predicate) 获取匹配规则定义中匹配到元素的所有位置 此方法对于某些无序集合的位置信息,以转换为数组后的位置为准static <T> Collection<T> intersection(Collection<T> coll1, Collection<T> coll2) 两个集合的交集 针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留最少的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c],此结果中只保留了两个cstatic <T> Collection<T> intersection(Collection<T> coll1, Collection<T> coll2, Collection<T>... otherColls) 多个集合的交集 针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留最少的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c],此结果中只保留了两个cstatic <T> Set<T> intersectOne(Collection<T> coll1, Collection<T> coll2, Collection<T>... otherColls) 多个集合的交集 针对一个集合中存在多个相同元素的情况,只保留一个 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c],此结果中只保留了一个cstatic booleanIterable是否为空static booleanisEmpty(Collection<?> collection) 集合是否为空static booleanisEmpty(Enumeration<?> enumeration) Enumeration是否为空static booleanIterator是否为空static booleanMap是否为空static booleanisEqualList(Collection<?> list1, Collection<?> list2) 判断两个Collection是否元素和顺序相同,返回true的条件是: 两个Collection必须长度相同 两个Collection元素相同index的对象必须equals,满足Objects.equals(Object, Object)此方法来自Apache-Commons-Collections4。static booleanisNotEmpty(Iterable<?> iterable) Iterable是否为空static booleanisNotEmpty(Collection<?> collection) 集合是否为非空static booleanisNotEmpty(Enumeration<?> enumeration) Enumeration是否为空static booleanisNotEmpty(Iterator<?> Iterator) Iterator是否为空static booleanisNotEmpty(Map<?, ?> map) Map是否为非空static <T> Stringjoin(Iterable<T> iterable, CharSequence conjunction) static <T> Stringjoin(Iterable<T> iterable, CharSequence conjunction, String prefix, String suffix) 以 conjunction 为分隔符将集合转换为字符串static <T> Stringjoin(Iterable<T> iterable, CharSequence conjunction, Function<T, ? extends CharSequence> func) 以 conjunction 为分隔符将集合转换为字符串static <T> Stringjoin(Iterator<T> iterator, CharSequence conjunction) joining(CharSequence delimiter) 提供任意对象的Join操作的Collector实现,对象默认调用toString方法joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix, Function<T, ? extends CharSequence> toStringFunc) 提供任意对象的Join操作的Collector实现joining(CharSequence delimiter, Function<T, ? extends CharSequence> toStringFunc) 提供任意对象的Join操作的Collector实现static <K> Set<K> keySet(Collection<Map<K, ?>> mapCollection) 获取指定Map列表中所有的Keystatic <T> intlastIndexOf(Collection<T> collection, Predicate<? super T> predicate) 获取匹配规则定义中匹配到元素的最后位置 此方法对于某些无序集合的位置信息,以转换为数组后的位置为准static <T> intlastIndexOf(List<T> list, Predicate<? super T> predicate) 获取匹配规则定义中匹配到元素的最后位置 此方法对于某些无序集合的位置信息,以转换为数组后的位置为准static <T> List<T> list(boolean isLinked) 新建一个空Liststatic <T> List<T> 新建一个List 提供的参数为null时返回空ArrayListstatic <T> List<T> list(boolean isLinked, Collection<T> collection) 新建一个Liststatic <T> List<T> list(boolean isLinked, Enumeration<T> enumration) 新建一个List 提供的参数为null时返回空ArrayListstatic <T> List<T> 新建一个List 提供的参数为null时返回空ArrayListstatic <T> List<T> list(boolean isLinked, T... values) 新建一个Liststatic <T,R> List <R> 通过func自定义一个规则,此规则将原集合中的元素转换成新的元素,生成新的列表返回 例如提供的是一个Bean列表,通过Function接口实现获取某个字段值,返回这个字段值组成的新列表static <K,V, M extends Map<K, V>>
BinaryOperator<M> mapMerger(BinaryOperator<V> mergeFunction) 用户合并map的BinaryOperator,传入合并前需要对value进行的操作static <T extends Comparable<? super T>>
Tmax(Collection<T> coll) 取最大值static <K,X, Y, V>
Map<K, V> merge(Map<K, X> map1, Map<K, Y> map2, BiFunction<X, Y, V> merge) 合并两个相同key类型的mapstatic <T extends Comparable<? super T>>
Tmin(Collection<T> coll) 取最小值static <T> ArrayList<T> newArrayList(Iterable<T> iterable) 新建一个ArrayList 提供的参数为null时返回空ArrayListstatic <T> ArrayList<T> newArrayList(Collection<T> collection) 新建一个ArrayListstatic <T> ArrayList<T> newArrayList(Enumeration<T> enumration) 新建一个ArrayList 提供的参数为null时返回空ArrayListstatic <T> ArrayList<T> newArrayList(Iterator<T> iter) 新建一个ArrayList 提供的参数为null时返回空ArrayListstatic <T> ArrayList<T> newArrayList(T... values) 新建一个ArrayListstatic <T> BlockingQueue<T> newBlockingQueue(int capacity, boolean isLinked) 新建BlockingQueue在队列为空时,获取元素的线程会等待队列变为非空 当队列满时,存储元素的线程会等待队列可用static <T> CopyOnWriteArrayList<T> newCopyOnWriteArrayList(Collection<T> collection) 新建一个CopyOnWriteArrayListstatic <T> HashSet<T> newHashSet(boolean isSorted, Collection<T> collection) 新建一个HashSetstatic <T> HashSet<T> newHashSet(boolean isSorted, Enumeration<T> enumration) 新建一个HashSetstatic <T> HashSet<T> newHashSet(boolean isSorted, Iterator<T> iter) 新建一个HashSetstatic <T> HashSet<T> newHashSet(boolean isSorted, T... ts) 新建一个HashSetstatic <T> HashSet<T> newHashSet(Collection<T> collection) 新建一个HashSetstatic <T> HashSet<T> newHashSet(T... ts) 新建一个HashSetstatic <T> LinkedHashSet<T> newLinkedHashSet(T... ts) 新建一个LinkedHashSetstatic <T> LinkedList<T> newLinkedList(T... values) 新建LinkedListstatic <T> List<T> of(T... ts) 像java11一样获取一个Liststatic <E> List<E> ofImmutableList(E... es) 不可变 Liststatic <E> Set<E> ofImmutableSet(E... es) 不可变 Setstatic <T> void填充List,以达到最小长度static <T> voidpadRight(Collection<T> list, int minLen, T padObj) 填充List,以达到最小长度static <T> List<T> 对指定List分页取值static <T> List<T> 切取部分数据 切取后的栈将减少这些元素static <T> List<T> 切取部分数据 切取后的栈将减少这些元素static int[]rainbow(int currentPage, int pageCount) 分页彩虹算法(默认展示10页)static int[]rainbow(int currentPage, int pageCount, int displayCount) 分页彩虹算法 通过传入的信息,生成一个分页列表显示static <T> Collection<T> removeAny(Collection<T> collection, T... elesRemoved) 去掉集合中的多个元素static <T extends CharSequence>
Collection<T> removeBlank(Collection<T> collection) 去除null或者""或者空白字符串 元素static <T extends CharSequence>
Collection<T> removeEmpty(Collection<T> collection) 去除null或者"" 元素static <T> Collection<T> removeNull(Collection<T> collection) 去除null元素static <T extends Collection<E>,E>
List<E> removeWithAddIf(T targetCollection, Predicate<? super E> predicate) 移除集合中的多个元素,并将结果存放到生成的新集合中后返回 此方法直接修改原集合static <T extends Collection<E>,E>
TremoveWithAddIf(T targetCollection, T resultCollection, Predicate<? super E> predicate) 移除集合中的多个元素,并将结果存放到指定的集合 此方法直接修改原集合static <T> List<T> 反序给定List,会在原List基础上直接修改static <T> List<T> 反序给定List,会创建一个新的List,原List数据不变static intringNextInt(int modulo, AtomicInteger atomicInteger) 通过cas操作 实现对指定值内的回环累加static intringNextIntByObject(Object object, AtomicInteger atomicInteger) 通过cas操作 实现对指定值内的回环累加static longringNextLong(long modulo, AtomicLong atomicLong) 通过cas操作 实现对指定值内的回环累加 此方法一般用于大量数据完成回环累加(如数据库中的值大于int最大值)static booleansafeContains(Collection<?> collection, Object value) 判断指定集合是否包含指定值,如果集合为空(null或者空),返回false,否则找到元素返回truestatic <T> List<T> setOrAppend(List<T> list, int index, T element) 设置或增加元素 当index小于List的长度时,替换指定位置的值,否则在尾部追加static <T> List<T> setOrPadding(List<T> list, int index, T element) 在指定位置设置元素。static <T> List<T> setOrPadding(List<T> list, int index, T element, T paddingElement) 在指定位置设置元素。static int获取Collection或者iterator的大小,此方法可以处理的对象类型如下: Collection - the collection size Map - the map size Array - the array size Iterator - the number of elements remaining in the iterator Enumeration - the number of elements remaining in the enumerationstatic <T> List<T> sort(Collection<T> collection, Comparator<? super T> comparator) 排序集合,排序不会修改原集合static <E> void对list的元素按照多个属性名称排序, list元素的属性可以是数字(byte、short、int、long、float、double等,支持正数、负数、0)、char、String、java.util.Datestatic <E> void给list的每个属性都指定是升序还是降序static <T> List<T> 针对List自然排序,排序会修改原Liststatic <T> List<T> sort(List<T> list, Comparator<? super T> c) 针对List排序,排序会修改原Liststatic <K,V> TreeMap <K, V> sort(Map<K, V> map, Comparator<? super K> comparator) 排序Mapstatic <K,V> LinkedHashMap <K, V> sortByEntry(Map<K, V> map, Comparator<Map.Entry<K, V>> comparator) 通过Entry排序,可以按照键排序,也可以按照值排序,亦或者两者综合排序sortByPinyin(List<String> list) 根据汉字的拼音顺序排序static <T> List<T> sortByProperty(Collection<T> collection, String property) 根据Bean的属性排序static <T> List<T> sortByProperty(List<T> list, String property) 根据Bean的属性排序sortEntryToList(Collection<Map.Entry<K, V>> collection) 将Set排序(根据Entry的值)static <T> List<T> sortPageAll(int pageNo, int pageSize, Comparator<T> comparator, Collection<T>... colls) 将多个集合排序并显示不同的段落(分页) 实现分页取局部static <K,V> LinkedHashMap <K, V> sortToMap(Collection<Map.Entry<K, V>> entryCollection, Comparator<Map.Entry<K, V>> comparator) 通过Entry排序,可以按照键排序,也可以按照值排序,亦或者两者综合排序static <T> List<T> 通过删除或替换现有元素或者原地添加新的元素来修改列表 并以列表形式返回被修改的内容。split(Collection<T> collection, int size) 对集合按照指定长度分段,每一个段为单独的集合,返回这个集合的列表对集合按照指定长度分段,每一个段为单独的集合,返回这个集合的列表将集合平均分成多个list,返回这个集合的列表static <T> List<T> sub(Collection<T> collection, int start, int end) 截取集合的部分static <T> List<T> sub(Collection<T> list, int start, int end, int step) 截取集合的部分static <T> List<T> 截取集合的部分static <T> List<T> 截取集合的部分 与List.subList(int, int)不同在于子列表是新的副本,操作子列表不会影响源列表static <T> Collection<T> subtract(Collection<T> coll1, Collection<T> coll2) 计算集合的单差集,即只返回【集合1】中有,但是【集合2】中没有的元素,例如:static <T> List<T> subtractToList(Collection<T> coll1, Collection<T> coll2) 计算集合的单差集,即只返回【集合1】中有,但是【集合2】中没有的元素 例如:static <T> voidswapElement(List<T> list, T element, T targetElement) 将指定元素交换到指定元素位置,其他元素的索引值不变 交换会修改原List如果集合中有多个相同元素,只交换第一个找到的元素static <T> void将指定元素交换到指定索引位置,其他元素的索引值不变 交换会修改原List如果集合中有多个相同元素,只交换第一个找到的元素static <E> Collection<E> toCollection(Iterable<E> iterable) static <T> CopyOnWriteArrayList<T> toCopyOnWriteArrayList(Collection<T> collection) 新建一个CopyOnWriteArrayListstatic <V,K> Map <K, V> toIdentityMap(Collection<V> collection, Function<V, K> key) 将collection转化为类型不变的mapCollection<V> ----> Map<K,V>static <V,K> Map <K, V> toIdentityMap(Collection<V> collection, Function<V, K> key, boolean isParallel) 将collection转化为类型不变的mapCollection<V> ----> Map<K,V>static <T> LinkedList<T> toLinkedList(T... values) 新建LinkedListstatic <T> ArrayList<T> 新建一个ArrayList 提供的参数为null时返回空ArrayListstatic <E,T> List <T> toList(Collection<E> collection, Function<E, T> function) 将collection转化为List集合,但是两者的泛型不同Collection<E> ------> List<T>static <E,T> List <T> toList(Collection<E> collection, Function<E, T> function, boolean isParallel) 将collection转化为List集合,但是两者的泛型不同Collection<E> ------> List<T>static <T> ArrayList<T> toList(Collection<T> collection) 新建一个ArrayListstatic <T> ArrayList<T> toList(Enumeration<T> enumeration) 新建一个ArrayList 提供的参数为null时返回空ArrayListstatic <T> ArrayList<T> 新建一个ArrayList 提供的参数为null时返回空ArrayListstatic <T> ArrayList<T> toList(T... values) 新建一个ArrayList行转列,合并相同的键,值合并为列表 将Map列表中相同key的值组成列表做为Map的value 是toMapList(Map)的逆方法 比如传入数据:static <K,V> HashMap <K, V> 将Entry集合转换为HashMap将数组转换为Map(HashMap),支持数组元素类型为:static <E,K, V> Map <K, V> toMap(Collection<E> collection, Function<E, K> key, Function<E, V> value) 将Collection转化为map(value类型与collection的泛型不同)Collection<E> -----> Map<K,V>static <E,K, V> Map <K, V> toMap(Collection<E> collection, Function<E, K> key, Function<E, V> value, boolean isParallel) toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction) 对null友好的 toMap 操作的Collector实现,默认使用HashMaptoMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier) 对null友好的 toMap 操作的Collector实现列转行 将Map中值列表分别按照其位置与key组成新的map 是toListMap(Iterable)的逆方法 比如传入数据:static <E,T> Set <T> toSet(Collection<E> collection, Function<E, T> function) 将collection转化为Set集合,但是两者的泛型不同Collection<E> ------> Set<T>static <E,T> Set <T> toSet(Collection<E> collection, Function<E, T> function, boolean isParallel) 将collection转化为Set集合,但是两者的泛型不同Collection<E> ------> Set<T>static inttotalPage(int totalCount, int pageSize) 根据总数计算总页数static <T> TreeSet<T> toTreeSet(Collection<T> collection, Comparator<T> comparator) 将集合转换为排序后的TreeSetstatic <F,T> Collection <T> trans(Collection<F> collection, Function<? super F, ? extends T> function) 使用给定的转换函数,转换源集合为新类型的集合static int[]transToStartEnd(int pageNo, int pageSize) 将页数和每页条目数转换为开始位置和结束位置 此方法用于不包括结束位置的分页方法 例如: 页码:1,每页10 = [0, 10] 页码:2,每页10 = [10, 20]static <T> Collection<T> union(Collection<T> coll1, Collection<T> coll2) 两个集合的并集 针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留最多的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c, c],此结果中只保留了三个cstatic <T> Collection<T> union(Collection<T> coll1, Collection<T> coll2, Collection<T>... otherColls) 多个集合的并集 针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留最多的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c, c],此结果中只保留了三个cstatic <T> List<T> unionAll(Collection<T> coll1, Collection<T> coll2, Collection<T>... otherColls) 多个集合的完全并集,类似于SQL中的“UNION ALL” 针对一个集合中存在多个相同元素的情况,保留全部元素 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c, c, a, b, c, c]static <T> Set<T> unionDistinct(Collection<T> coll1, Collection<T> coll2, Collection<T>... otherColls) 多个集合的非重复并集,类似于SQL中的“UNION DISTINCT” 针对一个集合中存在多个相同元素的情况,只保留一个 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c],此结果中只保留了一个cstatic <T> List<T> unmodifiable(List<T> list) 将对应List转换为不可修改的Liststatic <V> List<V> values(Collection<Map<?, V>> mapCollection) 获取指定Map列表中所有的Valuestatic <K,V> List <V> 从Map中获取指定键列表对应的值列表 如果key在map中不存在或key对应值为null,则返回值列表对应位置的值也为nullstatic <K,V> List <V> 从Map中获取指定键列表对应的值列表 如果key在map中不存在或key对应值为null,则返回值列表对应位置的值也为nullstatic <K,V> List <V> 从Map中获取指定键列表对应的值列表 如果key在map中不存在或key对应值为null,则返回值列表对应位置的值也为nullstatic <T> List<T> zero()获取一个初始大小为0的List,这个空List可变映射键值(参考Python的zip()函数),返回Map无序 例如: keys = a,b,c,d values = 1,2,3,4 delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分映射键值(参考Python的zip()函数) 例如: keys = a,b,c,d values = 1,2,3,4 delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分static <K,V> Map <K, V> zip(Collection<K> keys, Collection<V> values) 映射键值(参考Python的zip()函数) 例如: keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分
-
Constructor Details
-
CollKit
public CollKit()
-
-
Method Details
-
isEmpty
集合是否为空- Parameters:
collection- 集合- Returns:
- 是否为空
-
isEmpty
-
isEmpty
Iterable是否为空- Parameters:
iterable- Iterable对象- Returns:
- 是否为空
- See Also:
-
isEmpty
Iterator是否为空- Parameters:
Iterator- Iterator对象- Returns:
- 是否为空
- See Also:
-
isEmpty
Enumeration是否为空- Parameters:
enumeration-Enumeration- Returns:
- 是否为空
-
isNotEmpty
集合是否为非空- Parameters:
collection- 集合- Returns:
- 是否为非空
-
isNotEmpty
Map是否为非空- Parameters:
map- 集合- Returns:
- 是否为非空
- See Also:
-
isNotEmpty
Iterable是否为空- Parameters:
iterable- Iterable对象- Returns:
- 是否为空
- See Also:
-
isNotEmpty
Iterator是否为空- Parameters:
Iterator- Iterator对象- Returns:
- 是否为空
- See Also:
-
isNotEmpty
Enumeration是否为空- Parameters:
enumeration-Enumeration- Returns:
- 是否为空
-
isEqualList
判断两个Collection是否元素和顺序相同,返回true的条件是:- 两个
Collection必须长度相同 - 两个
Collection元素相同index的对象必须equals,满足Objects.equals(Object, Object)
- Parameters:
list1- 列表1list2- 列表2- Returns:
- 是否相同
- 两个
-
hasNull
是否包含null元素- Parameters:
iterable- 被检查的Iterable对象,如果为null返回true- Returns:
- 是否包含
null元素 - See Also:
-
emptyIfNull
如果提供的集合为null,返回一个不可变的默认空集合,否则返回原集合 空集合使用Collections.emptySet()- Type Parameters:
T- 集合元素类型- Parameters:
set- 提供的集合,可能为null- Returns:
- 原集合,若为null返回空集合
-
emptyIfNull
如果提供的集合为null,返回一个不可变的默认空集合,否则返回原集合 空集合使用Collections.emptyList()- Type Parameters:
T- 集合元素类型- Parameters:
list- 提供的集合,可能为null- Returns:
- 原集合,若为null返回空集合
-
defaultIfEmpty
如果给定集合为空,返回默认集合- Type Parameters:
T- 集合类型E- 集合元素类型- Parameters:
collection- 集合defaultCollection- 默认数组- Returns:
- 非空(empty)的原集合或默认集合
-
defaultIfEmpty
public static <T extends Collection<E>,E> T defaultIfEmpty(T collection, Supplier<? extends T> supplier) 如果给定集合为空,返回默认集合- Type Parameters:
T- 集合类型E- 集合元素类型- Parameters:
collection- 集合supplier- 默认值懒加载函数- Returns:
- 非空(empty)的原集合或默认集合
-
empty
获取一个空List,这个空List不可变- Type Parameters:
T- 元素类型- Returns:
- 空的List
- See Also:
-
zero
获取一个初始大小为0的List,这个空List可变- Type Parameters:
T- 元素类型- Returns:
- 空的List
-
union
两个集合的并集 针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留最多的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c, c],此结果中只保留了三个c- Type Parameters:
T- 集合元素类型- Parameters:
coll1- 集合1coll2- 集合2- Returns:
- 并集的集合, 返回
ArrayList
-
union
public static <T> Collection<T> union(Collection<T> coll1, Collection<T> coll2, Collection<T>... otherColls) 多个集合的并集 针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留最多的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c, c],此结果中只保留了三个c- Type Parameters:
T- 集合元素类型- Parameters:
coll1- 集合1coll2- 集合2otherColls- 其它集合- Returns:
- 并集的集合, 返回
ArrayList
-
unionDistinct
public static <T> Set<T> unionDistinct(Collection<T> coll1, Collection<T> coll2, Collection<T>... otherColls) 多个集合的非重复并集,类似于SQL中的“UNION DISTINCT” 针对一个集合中存在多个相同元素的情况,只保留一个 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c],此结果中只保留了一个c- Type Parameters:
T- 集合元素类型- Parameters:
coll1- 集合1coll2- 集合2otherColls- 其它集合- Returns:
- 并集的集合,返回
LinkedHashSet
-
unionAll
public static <T> List<T> unionAll(Collection<T> coll1, Collection<T> coll2, Collection<T>... otherColls) 多个集合的完全并集,类似于SQL中的“UNION ALL” 针对一个集合中存在多个相同元素的情况,保留全部元素 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c, c, a, b, c, c]- Type Parameters:
T- 集合元素类型- Parameters:
coll1- 集合1coll2- 集合2otherColls- 其它集合- Returns:
- 并集的集合,返回
ArrayList
-
intersection
两个集合的交集 针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留最少的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c],此结果中只保留了两个c- Type Parameters:
T- 集合元素类型- Parameters:
coll1- 集合1coll2- 集合2- Returns:
- 并集的集合, 返回
ArrayList
-
intersection
public static <T> Collection<T> intersection(Collection<T> coll1, Collection<T> coll2, Collection<T>... otherColls) 多个集合的交集 针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留最少的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c],此结果中只保留了两个c- Type Parameters:
T- 集合元素类型- Parameters:
coll1- 集合1coll2- 集合2otherColls- 其它集合- Returns:
- 并集的集合, 返回
ArrayList
-
intersectOne
public static <T> Set<T> intersectOne(Collection<T> coll1, Collection<T> coll2, Collection<T>... otherColls) 多个集合的交集 针对一个集合中存在多个相同元素的情况,只保留一个 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c],此结果中只保留了一个c- Type Parameters:
T- 集合元素类型- Parameters:
coll1- 集合1coll2- 集合2otherColls- 其它集合- Returns:
- 并集的集合,返回
LinkedHashSet
-
subtract
计算集合的单差集,即只返回【集合1】中有,但是【集合2】中没有的元素,例如:subtract([1,2,3,4],[2,3,4,5]) - [1]- Type Parameters:
T- 元素类型- Parameters:
coll1- 集合1coll2- 集合2- Returns:
- 单差集
-
subtractToList
计算集合的单差集,即只返回【集合1】中有,但是【集合2】中没有的元素 例如:subtractToList([1,2,3,4],[2,3,4,5]) - [1]- Type Parameters:
T- 元素类型- Parameters:
coll1- 集合1coll2- 集合2- Returns:
- 单差集
-
disjunction
两个集合的差集 针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留两个集合中此元素个数差的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[c],此结果中只保留了一个 任意一个集合为空,返回另一个集合 两个集合无交集则返回两个集合的组合- Type Parameters:
T- 集合元素类型- Parameters:
coll1- 集合1coll2- 集合2- Returns:
- 差集的集合, 返回
ArrayList
-
contains
public static <T> boolean contains(T[] array, T element) 检查给定数组是否包含给定元素- Type Parameters:
T- 通用标签- Parameters:
array- 数组要检查的数组element- 要查找的元素- Returns:
- 如果集合为空(null或者空), 返回
false,否则找到元素返回true
-
contains
判断指定集合是否包含指定值,如果集合为空(null或者空),返回false,否则找到元素返回true- Parameters:
collection- 集合value- 需要查找的值- Returns:
- 如果集合为空(null或者空), 返回
false,否则找到元素返回true
-
safeContains
判断指定集合是否包含指定值,如果集合为空(null或者空),返回false,否则找到元素返回true- Parameters:
collection- 集合value- 需要查找的值- Returns:
- 果集合为空(null或者空),返回
false,否则找到元素返回true
-
contains
-
contains
检查给定枚举是否包含给定元素.- Parameters:
enumeration- 要检查的枚举element- 要查找的元素- Returns:
true如果找到,false否则返回
-
contains
自定义函数判断集合是否包含某类值- Type Parameters:
T- 值类型- Parameters:
collection- 集合containFunc- 自定义判断函数- Returns:
- 是否包含自定义规则的值
-
containsAny
其中一个集合在另一个集合中是否至少包含一个元素,既是两个集合是否至少有一个共同的元素- Parameters:
coll1- 集合1coll2- 集合2- Returns:
- 其中一个集合在另一个集合中是否至少包含一个元素
-
containsAll
集合1中是否包含集合2中所有的元素,即集合2是否为集合1的子集- Parameters:
coll1- 集合1coll2- 集合2- Returns:
- 集合1中是否包含集合2中所有的元素
-
countMap
-
join
public static <T> String join(Iterable<T> iterable, CharSequence conjunction, Function<T, ? extends CharSequence> func) 以 conjunction 为分隔符将集合转换为字符串- Type Parameters:
T- 集合元素类型- Parameters:
iterable-Iterableconjunction- 分隔符func- 集合元素转换器,将元素转换为字符串- Returns:
- 连接后的字符串
-
join
-
join
- Type Parameters:
T- 集合元素类型- Parameters:
iterator- 集合conjunction- 分隔符- Returns:
- 连接后的字符串
- See Also:
-
join
-
popPart
-
popPart
-
newHashSet
新建一个HashSet- Type Parameters:
T- 集合元素类型- Parameters:
ts- 元素数组- Returns:
- HashSet对象
-
newLinkedHashSet
新建一个LinkedHashSet- Type Parameters:
T- 集合元素类型- Parameters:
ts- 元素数组- Returns:
- HashSet对象
-
newHashSet
新建一个HashSet- Type Parameters:
T- 集合元素类型- Parameters:
isSorted- 是否有序,有序返回LinkedHashSet,否则返回HashSetts- 元素数组- Returns:
- HashSet对象
-
newHashSet
新建一个HashSet- Type Parameters:
T- 集合元素类型- Parameters:
collection- 集合- Returns:
- HashSet对象
-
newHashSet
新建一个HashSet- Type Parameters:
T- 集合元素类型- Parameters:
isSorted- 是否有序,有序返回LinkedHashSet,否则返回HashSetcollection- 集合,用于初始化Set- Returns:
- HashSet对象
-
newHashSet
新建一个HashSet- Type Parameters:
T- 集合元素类型- Parameters:
isSorted- 是否有序,有序返回LinkedHashSet,否则返回HashSetiter-Iterator- Returns:
- HashSet对象
-
newHashSet
新建一个HashSet- Type Parameters:
T- 集合元素类型- Parameters:
isSorted- 是否有序,有序返回LinkedHashSet,否则返回HashSetenumration-Enumeration- Returns:
- HashSet对象
-
newArrayList
新建一个ArrayList- Type Parameters:
T- 集合元素类型- Parameters:
values- 数组- Returns:
- ArrayList对象
-
newArrayList
新建一个ArrayList- Type Parameters:
T- 集合元素类型- Parameters:
collection- 集合- Returns:
- ArrayList对象
-
newArrayList
-
newArrayList
-
newArrayList
新建一个ArrayList 提供的参数为null时返回空ArrayList- Type Parameters:
T- 集合元素类型- Parameters:
enumration-Enumeration- Returns:
- ArrayList对象
-
newLinkedList
新建LinkedList- Type Parameters:
T- 类型- Parameters:
values- 数组- Returns:
- LinkedList
-
newCopyOnWriteArrayList
新建一个CopyOnWriteArrayList- Type Parameters:
T- 集合元素类型- Parameters:
collection- 集合- Returns:
CopyOnWriteArrayList
-
newBlockingQueue
新建BlockingQueue在队列为空时,获取元素的线程会等待队列变为非空 当队列满时,存储元素的线程会等待队列可用- Type Parameters:
T- 对象- Parameters:
capacity- 容量isLinked- 是否为链表形式- Returns:
BlockingQueue
-
list
新建一个空List- Type Parameters:
T- 集合元素类型- Parameters:
isLinked- 是否新建LinkedList- Returns:
- List对象
-
list
新建一个List- Type Parameters:
T- 集合元素类型- Parameters:
isLinked- 是否新建LinkedListvalues- 数组- Returns:
- List对象
-
list
新建一个List- Type Parameters:
T- 集合元素类型- Parameters:
isLinked- 是否新建LinkedListcollection- 集合- Returns:
- List对象
-
list
-
list
-
list
新建一个List 提供的参数为null时返回空ArrayList- Type Parameters:
T- 集合元素类型- Parameters:
isLinked- 是否新建LinkedListenumration-Enumeration- Returns:
- ArrayList对象
-
toList
新建一个ArrayList- Type Parameters:
T- 集合元素类型- Parameters:
values- 数组- Returns:
- ArrayList对象
-
toLinkedList
新建LinkedList- Type Parameters:
T- 类型- Parameters:
values- 数组- Returns:
- LinkedList
-
toCopyOnWriteArrayList
新建一个CopyOnWriteArrayList- Type Parameters:
T- 集合元素类型- Parameters:
collection- 集合- Returns:
CopyOnWriteArrayList
-
toList
新建一个ArrayList- Type Parameters:
T- 集合元素类型- Parameters:
collection- 集合- Returns:
- ArrayList对象
-
toList
-
toList
-
toList
新建一个ArrayList 提供的参数为null时返回空ArrayList- Type Parameters:
T- 集合元素类型- Parameters:
enumeration-Enumeration- Returns:
- ArrayList对象
-
indexOf
获取匹配规则定义中匹配到元素的第一个位置 此方法对于某些无序集合的位置信息,以转换为数组后的位置为准- Type Parameters:
T- 元素类型- Parameters:
collection- 集合predicate- 匹配器,为空则全部匹配- Returns:
- 第一个位置
-
lastIndexOf
-
lastIndexOf
获取匹配规则定义中匹配到元素的最后位置 此方法对于某些无序集合的位置信息,以转换为数组后的位置为准- Type Parameters:
T- 元素类型- Parameters:
collection- 集合predicate- 匹配器,为空则全部匹配- Returns:
- 最后一个位置
-
indexOfAll
获取匹配规则定义中匹配到元素的所有位置 此方法对于某些无序集合的位置信息,以转换为数组后的位置为准- Type Parameters:
T- 元素类型- Parameters:
collection- 集合predicate- 匹配器,为空则全部匹配- Returns:
- 位置数组
-
unmodifiable
-
create
创建新的集合对象,返回具体的泛型集合- Type Parameters:
T- 集合元素类型,rawtype 如 ArrayList.class, EnumSet.class ...- Parameters:
collectionType- 集合类型- Returns:
- 集合类型对应的实例
-
create
创建新的集合对象,返回具体的泛型集合- Type Parameters:
T- 集合元素类型,rawtype 如 ArrayList.class, EnumSet.class ...- Parameters:
collectionType- 集合类型elementType- 集合元素类,只用于EnumSet创建,如果创建EnumSet,则此参数必须非空- Returns:
- 集合类型对应的实例
-
createMap
-
distinct
去重集合- Type Parameters:
T- 集合元素类型- Parameters:
collection- 集合- Returns:
List
-
distinct
-
distinct
public static <T,K> List<T> distinct(Collection<T> collection, Function<T, K> uniqueGenerator, boolean override) 根据函数生成的KEY去重集合,如根据Bean的某个或者某些字段完成去重 去重可选是保留最先加入的值还是后加入的值- Type Parameters:
T- 集合元素类型K- 唯一键类型- Parameters:
collection- 集合override- 是否覆盖模式,如果为true,加入的新值会覆盖相同key的旧值,否则会忽略新加值- Returns:
ArrayList
-
sub
-
sub
截取集合的部分 与List.subList(int, int)不同在于子列表是新的副本,操作子列表不会影响源列表- Type Parameters:
T- 集合元素类型- Parameters:
list- 被截取的数组start- 开始位置(包含)end- 结束位置(不包含)step- 步进- Returns:
- 截取后的数组, 当开始位置超过最大时, 返回空的List
-
sub
截取集合的部分- Type Parameters:
T- 集合元素类型- Parameters:
collection- 被截取的数组start- 开始位置(包含)end- 结束位置(不包含)- Returns:
- 截取后的数组, 当开始位置超过最大时, 返回null
-
sub
截取集合的部分- Type Parameters:
T- 集合元素类型- Parameters:
list- 被截取的数组start- 开始位置(包含)end- 结束位置(不包含)step- 步进- Returns:
- 截取后的数组, 当开始位置超过最大时, 返回空集合
-
split
-
split
对集合按照指定长度分段,每一个段为单独的集合,返回这个集合的列表- Type Parameters:
T- 集合元素类型- Parameters:
collection- 集合size- 每个段的长度- Returns:
- 分段列表
-
splitAvg
将集合平均分成多个list,返回这个集合的列表CollKit.splitAvg(null, 3); // [[], [], []] CollKit.splitAvg(Arrays.asList(1, 2, 3, 4), 2); // [[1, 2], [3, 4]] CollKit.splitAvg(Arrays.asList(1, 2, 3), 5); // [[1], [2], [3], [], []] CollKit.splitAvg(Arrays.asList(1, 2, 3), 2); // [[1, 2], [3]]
- Type Parameters:
T- 集合元素类型- Parameters:
list- 集合limit- 要均分成几个集合- Returns:
- 分段列表
-
filter
过滤 过滤过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能:1、过滤出需要的对象,如果返回null表示这个元素对象抛弃 2、修改元素对象,返回集合中为修改后的对象
- Type Parameters:
T- 集合元素类型- Parameters:
collection- 集合editor- 编辑器接口- Returns:
- 过滤后的数组
-
filter
-
filter
过滤集合,此方法在原集合上直接修改 通过实现Filter接口,完成元素的过滤,这个Filter实现可以实现以下功能:1、过滤出需要的对象,
Predicate.test(Object)方法返回false的对象将被使用Iterator.remove()方法移除- Type Parameters:
T- 集合类型E- 集合元素类型- Parameters:
iter- 集合filter- 过滤器接口- Returns:
- 编辑后的集合
-
filter
过滤集合,此方法在原集合上直接修改 通过实现Filter接口,完成元素的过滤,这个Filter实现可以实现以下功能:1、过滤出需要的对象,
Predicate.test(Object)方法返回false的对象将被使用Iterator.remove()方法移除- Type Parameters:
E- 集合元素类型- Parameters:
iter- 集合filter- 过滤器接口- Returns:
- 编辑后的集合
-
removeNull
去除null元素- Type Parameters:
T- 对象- Parameters:
collection- 集合- Returns:
- 处理后的集合
-
removeAny
去掉集合中的多个元素- Type Parameters:
T- 对象- Parameters:
collection- 集合elesRemoved- 被去掉的元素数组- Returns:
- 原集合
-
removeEmpty
去除null或者"" 元素- Type Parameters:
T- 对象- Parameters:
collection- 集合- Returns:
- 处理后的集合
-
removeBlank
去除null或者""或者空白字符串 元素- Type Parameters:
T- 对象- Parameters:
collection- 集合- Returns:
- 处理后的集合
-
removeWithAddIf
public static <T extends Collection<E>,E> T removeWithAddIf(T targetCollection, T resultCollection, Predicate<? super E> predicate) 移除集合中的多个元素,并将结果存放到指定的集合 此方法直接修改原集合- Type Parameters:
T- 集合类型E- 集合元素类型- Parameters:
targetCollection- 被操作移除元素的集合resultCollection- 存放移除结果的集合predicate- 用于是否移除判断的过滤器- Returns:
- 移除结果的集合
-
removeWithAddIf
public static <T extends Collection<E>,E> List<E> removeWithAddIf(T targetCollection, Predicate<? super E> predicate) 移除集合中的多个元素,并将结果存放到生成的新集合中后返回 此方法直接修改原集合- Type Parameters:
T- 集合类型E- 集合元素类型- Parameters:
targetCollection- 被操作移除元素的集合predicate- 用于是否移除判断的过滤器- Returns:
- 移除结果的集合
-
extract
-
extract
-
map
public static <T,R> List<R> map(Iterable<T> collection, Function<? super T, ? extends R> func, boolean ignoreNull) 通过func自定义一个规则,此规则将原集合中的元素转换成新的元素,生成新的列表返回 例如提供的是一个Bean列表,通过Function接口实现获取某个字段值,返回这个字段值组成的新列表- Type Parameters:
T- 输入类型R- 结果类型- Parameters:
collection- 原集合func- 编辑函数ignoreNull- 是否忽略空值,这里的空值包括函数处理前和处理后的null值- Returns:
- 抽取后的新列表
-
getFieldValues
-
findOne
-
findOneByField
查找第一个匹配元素对象 如果集合元素是Map,则比对键和值是否相同,相同则返回 如果为普通Bean,则通过反射比对元素字段名对应的字段值是否相同,相同则返回 如果给定字段值参数是null且元素对象中的字段值也为null则认为相同- Type Parameters:
T- 集合元素类型- Parameters:
collection- 集合,集合元素可以是Bean或者MapfieldName- 集合元素对象的字段名或map的键fieldValue- 集合元素对象的字段值或map的值- Returns:
- 满足条件的第一个元素
-
count
-
zip
映射键值(参考Python的zip()函数) 例如: keys = a,b,c,d values = 1,2,3,4 delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分- Parameters:
keys- 键列表values- 值列表delimiter- 分隔符isOrder- 是否有序- Returns:
- Map
-
zip
-
zip
映射键值(参考Python的zip()函数) 例如: keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分- Type Parameters:
K- 键类型V- 值类型- Parameters:
keys- 键列表values- 值列表- Returns:
- Map
-
toMap
-
toMap
将数组转换为Map(HashMap),支持数组元素类型为:Map.Entry 长度大于1的数组(取前两个值),如果不满足跳过此元素 Iterable 长度也必须大于1(取前两个值),如果不满足跳过此元素 Iterator 长度也必须大于1(取前两个值),如果不满足跳过此元素
Map<Object, Object> colorMap = toMap(new String[][] {{ {"RED", "#FF0000"}, {"GREEN", "#00FF00"}, {"BLUE", "#0000FF"}});参考:commons-lang
- Parameters:
array- 数组 元素类型为Map.Entry、数组、Iterable、Iterator- Returns:
HashMap- See Also:
-
toMap
public static <E,K, Map<K,V> V> toMap(Collection<E> collection, Function<E, K> key, Function<E, V> value) 将Collection转化为map(value类型与collection的泛型不同)Collection<E> -----> Map<K,V>- Type Parameters:
E- collection中的泛型K- map中的key类型V- map中的value类型- Parameters:
collection- 需要转化的集合key- E类型转化为K类型的lambda方法value- E类型转化为V类型的lambda方法- Returns:
- 转化后的map
-
toMap
public static <E,K, Map<K,V> V> toMap(Collection<E> collection, Function<E, K> key, Function<E, V> value, boolean isParallel) - Type Parameters:
E- collection中的泛型K- map中的key类型V- map中的value类型- Parameters:
collection- 需要转化的集合key- E类型转化为K类型的lambda方法value- E类型转化为V类型的lambda方法isParallel- 是否并行流- Returns:
- 转化后的map
-
toMap
public static <T,K, Collector<T,U> ?, toMapMap<K, U>> (Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction) 对null友好的 toMap 操作的Collector实现,默认使用HashMap- Type Parameters:
T- 实体类型K- map中key的类型U- map中value的类型- Parameters:
keyMapper- 指定map中的keyvalueMapper- 指定map中的valuemergeFunction- 合并前对value进行的操作- Returns:
- 对null友好的 toMap 操作的
Collector实现
-
toMap
public static <T,K, Collector<T,U, M extends Map<K, U>> ?, toMapM> (Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier) 对null友好的 toMap 操作的Collector实现- Type Parameters:
T- 实体类型K- map中key的类型U- map中value的类型M- map的类型- Parameters:
keyMapper- 指定map中的keyvalueMapper- 指定map中的valuemergeFunction- 合并前对value进行的操作mapSupplier- 最终需要的map类型- Returns:
- 对null友好的 toMap 操作的
Collector实现
-
toTreeSet
将集合转换为排序后的TreeSet- Type Parameters:
T- 集合元素类型- Parameters:
collection- 集合comparator- 比较器- Returns:
- treeSet
-
asEnumeration
Iterator转换为EnumerationAdapt the specified
Iteratorto theEnumerationinterface.- Type Parameters:
E- 集合元素类型- Parameters:
iter-Iterator- Returns:
Enumeration
-
asIterator
Enumeration转换为IteratorAdapt the specified
Enumerationto theIteratorinterface- Type Parameters:
E- 集合元素类型- Parameters:
e-Enumeration- Returns:
Iterator- See Also:
-
asIterable
-
toCollection
- Type Parameters:
E- 集合元素类型- Parameters:
iterable-Iterable- Returns:
Collection或者ArrayList
-
toListMap
行转列,合并相同的键,值合并为列表 将Map列表中相同key的值组成列表做为Map的value 是toMapList(Map)的逆方法 比如传入数据:[ {a: 1, b: 1, c: 1} {a: 2, b: 2} {a: 3, b: 3} {a: 4} ]结果是:
{ a: [1,2,3,4] b: [1,2,3,] c: [1] }- Type Parameters:
K- 键类型V- 值类型- Parameters:
mapList- Map列表- Returns:
- Map
- See Also:
-
toMapList
列转行 将Map中值列表分别按照其位置与key组成新的map 是toListMap(Iterable)的逆方法 比如传入数据:{ a: [1,2,3,4] b: [1,2,3,] c: [1] }结果是:
[ {a: 1, b: 1, c: 1} {a: 2, b: 2} {a: 3, b: 3} {a: 4} ]- Type Parameters:
K- 键类型V- 值类型- Parameters:
listMap- 列表Map- Returns:
- Map列表
- See Also:
-
addAll
将指定对象全部加入到集合中 提供的对象如果为集合类型,会自动转换为目标元素类型- Type Parameters:
T- 元素类型- Parameters:
collection- 被加入的集合value- 对象,可能为Iterator、Iterable、Enumeration、Array- Returns:
- 被加入集合
-
addAll
将指定对象全部加入到集合中 提供的对象如果为集合类型,会自动转换为目标元素类型- Type Parameters:
T- 元素类型- Parameters:
collection- 被加入的集合value- 对象,可能为Iterator、Iterable、Enumeration、Array,或者与集合元素类型一致elementType- 元素类型,为空时,使用Object类型来接纳所有类型- Returns:
- 被加入集合
-
addAll
加入全部- Type Parameters:
T- 集合元素类型- Parameters:
collection- 被加入的集合Collectioniterator- 要加入的Iterator- Returns:
- 原集合
-
addAll
加入全部- Type Parameters:
T- 集合元素类型- Parameters:
collection- 被加入的集合Collectioniterable- 要加入的内容Iterable- Returns:
- 原集合
-
addAll
加入全部- Type Parameters:
T- 集合元素类型- Parameters:
collection- 被加入的集合Collectionenumeration- 要加入的内容Enumeration- Returns:
- 原集合
-
addAll
加入全部- Type Parameters:
T- 集合元素类型- Parameters:
collection- 被加入的集合Collectionvalues- 要加入的内容数组- Returns:
- 原集合
-
addAll
-
addIfAbsent
一个对象不为空且不存在于该集合中时,加入到该集合中null, null = false [], null = false null, "123" = false ["123"], "123" = false [], "123" => true ["456"], "123" = true [Animal{"name": "jack"}], Dog{"name": "jack"} = true- Type Parameters:
T- 集合元素类型S- 要添加的元素类型【为集合元素类型的类型或子类型】- Parameters:
collection- 被加入的集合object- 要添加到集合的对象- Returns:
- 是否添加成功
-
addAllIfNotContains
-
splice
-
get
获取集合中指定下标的元素值,下标可以为负数,例如-1表示最后一个元素 如果元素越界,返回null- Type Parameters:
T- 元素类型- Parameters:
collection- 集合index- 下标,支持负数- Returns:
- 元素值
-
getAny
获取集合中指定多个下标的元素值,下标可以为负数,例如-1表示最后一个元素- Type Parameters:
T- 元素类型- Parameters:
collection- 集合indexes- 下标,支持负数- Returns:
- 元素值列表
-
getFirst
-
getFirst
-
getLast
获取集合的最后一个元素- Type Parameters:
T- 集合元素类型- Parameters:
collection-Collection- Returns:
- 最后一个元素
-
valuesOf
-
valuesOf
-
valuesOf
-
page
-
sort
-
sort
排序集合,排序不会修改原集合- Type Parameters:
T- 集合元素类型- Parameters:
collection- 集合comparator- 比较器- Returns:
- treeSet
-
sort
针对List排序,排序会修改原List- Type Parameters:
T- 元素类型- Parameters:
list- 被排序的Listc-Comparator,null表示自然排序(null安全的)- Returns:
- 原list
- See Also:
-
sort
排序Map- Type Parameters:
K- 键类型V- 值类型- Parameters:
map- Mapcomparator- Entry比较器- Returns:
TreeMap
-
sort
-
sort
-
sortPageAll
public static <T> List<T> sortPageAll(int pageNo, int pageSize, Comparator<T> comparator, Collection<T>... colls) 将多个集合排序并显示不同的段落(分页) 实现分页取局部- Type Parameters:
T- 集合元素类型- Parameters:
pageNo- 页码,从1开始计数,0和1效果相同pageSize- 每页的条目数comparator- 比较器colls- 集合数组- Returns:
- 分页后的段落内容
-
sortByProperty
根据Bean的属性排序- Type Parameters:
T- 元素类型- Parameters:
collection- 集合,会被转换为Listproperty- 属性名- Returns:
- 排序后的List
-
sortByProperty
-
sortByPinyin
-
sortToMap
public static <K,V> LinkedHashMap<K,V> sortToMap(Collection<Map.Entry<K, V>> entryCollection, Comparator<Map.Entry<K, V>> comparator) 通过Entry排序,可以按照键排序,也可以按照值排序,亦或者两者综合排序- Type Parameters:
K- 键类型V- 值类型- Parameters:
entryCollection- Entry集合comparator-Comparator- Returns:
LinkedList
-
sortByEntry
public static <K,V> LinkedHashMap<K,V> sortByEntry(Map<K, V> map, Comparator<Map.Entry<K, V>> comparator) 通过Entry排序,可以按照键排序,也可以按照值排序,亦或者两者综合排序- Type Parameters:
K- 键类型V- 值类型- Parameters:
map- 被排序的Mapcomparator-Comparator- Returns:
LinkedList
-
sortEntryToList
将Set排序(根据Entry的值)- Type Parameters:
K- 键类型V- 值类型- Parameters:
collection- 被排序的Collection- Returns:
- 排序后的Set
-
group
分组,按照CollKit.Hash接口定义的hash算法,集合中的元素放入hash值对应的子列表中- Type Parameters:
T- 元素类型- Parameters:
collection- 被分组的集合hash- Hash值算法,决定元素放在第几个分组的规则- Returns:
- 分组后的集合
-
groupByField
根据元素的指定字段名分组,非Bean都放在第一个分组中- Type Parameters:
T- 元素类型- Parameters:
collection- 集合fieldName- 元素Bean中的字段名,非Bean都放在第一个分组中- Returns:
- 分组列表
-
forEach
循环遍历Iterator,使用CollKit.Consumer接受遍历的每条数据,并针对每条数据做处理- Type Parameters:
T- 集合元素类型- Parameters:
iterator-Iteratorconsumer-CollKit.Consumer遍历的每条数据处理器
-
forEach
循环遍历Enumeration,使用CollKit.Consumer接受遍历的每条数据,并针对每条数据做处理- Type Parameters:
T- 集合元素类型- Parameters:
enumeration-Enumerationconsumer-CollKit.Consumer遍历的每条数据处理器
-
forEach
循环遍历Map,使用CollKit.KVConsumer接受遍历的每条数据,并针对每条数据做处理- Type Parameters:
K- Key类型V- Value类型- Parameters:
map-MapkvConsumer-CollKit.KVConsumer遍历的每条数据处理器
-
reverse
-
reverse
-
forceGetFieldValue
-
setOrAppend
-
setOrPadding
-
setOrPadding
-
transToStartEnd
public static int[] transToStartEnd(int pageNo, int pageSize) 将页数和每页条目数转换为开始位置和结束位置 此方法用于不包括结束位置的分页方法 例如: 页码:1,每页10 = [0, 10] 页码:2,每页10 = [10, 20]- Parameters:
pageNo- 页码(从1计数)pageSize- 每页条目数- Returns:
- 第一个数为开始位置, 第二个数为结束位置
-
totalPage
public static int totalPage(int totalCount, int pageSize) 根据总数计算总页数- Parameters:
totalCount- 总数pageSize- 每页数- Returns:
- 总页数
-
rainbow
public static int[] rainbow(int currentPage, int pageCount, int displayCount) 分页彩虹算法 通过传入的信息,生成一个分页列表显示- Parameters:
currentPage- 当前页pageCount- 总页数displayCount- 每屏展示的页数- Returns:
- 分页条
-
rainbow
public static int[] rainbow(int currentPage, int pageCount) 分页彩虹算法(默认展示10页)- Parameters:
currentPage- 当前页pageCount- 总页数- Returns:
- 分页条
-
firstNotNullElem
找到第一个不为 null 的元素- Type Parameters:
T- 泛型- Parameters:
list- 列表- Returns:
- 不为 null 的元素
-
concat
Concatenates 2 arrays- Type Parameters:
T- 对象- Parameters:
one- 数组1other- 数组2clazz- 数组类- Returns:
- 新数组
-
of
像java11一样获取一个List- Type Parameters:
T- 对象类型- Parameters:
ts- 对象- Returns:
- 不可修改List
-
ofImmutableSet
不可变 Set- Type Parameters:
E- 泛型- Parameters:
es- 对象- Returns:
- 集合
-
ofImmutableList
不可变 List- Type Parameters:
E- 泛型- Parameters:
es- 对象- Returns:
- 集合
-
keySet
获取指定Map列表中所有的Key- Type Parameters:
K- 键类型- Parameters:
mapCollection- Map列表- Returns:
- key集合
-
values
获取指定Map列表中所有的Value- Type Parameters:
V- 值类型- Parameters:
mapCollection- Map列表- Returns:
- Value集合
-
max
取最大值- Type Parameters:
T- 元素类型- Parameters:
coll- 集合- Returns:
- 最大值
- See Also:
-
min
取最小值- Type Parameters:
T- 元素类型- Parameters:
coll- 集合- Returns:
- 最小值
- See Also:
-
clear
清除一个或多个集合内的元素,每个集合调用clear()方法- Parameters:
collections- 一个或多个集合
-
padLeft
填充List,以达到最小长度- Type Parameters:
T- 集合元素类型- Parameters:
list- 列表minLen- 最小长度padObj- 填充的对象
-
padRight
填充List,以达到最小长度- Type Parameters:
T- 集合元素类型- Parameters:
list- 列表minLen- 最小长度padObj- 填充的对象
-
trans
public static <F,T> Collection<T> trans(Collection<F> collection, Function<? super F, ? extends T> function) 使用给定的转换函数,转换源集合为新类型的集合- Type Parameters:
F- 源元素类型T- 目标元素类型- Parameters:
collection- 集合function- 转换函数- Returns:
- 新类型的集合
-
size
获取Collection或者iterator的大小,此方法可以处理的对象类型如下:- Collection - the collection size
- Map - the map size
- Array - the array size
- Iterator - the number of elements remaining in the iterator
- Enumeration - the number of elements remaining in the enumeration
- Parameters:
object- 可以为空的对象- Returns:
- 如果object为空则返回0
- Throws:
IllegalArgumentException- 参数object不是Collection或者iterator
-
toIdentityMap
将collection转化为类型不变的mapCollection<V> ----> Map<K,V>- Type Parameters:
V- collection中的泛型K- map中的key类型- Parameters:
collection- 需要转化的集合key- V类型转化为K类型的lambda方法- Returns:
- 转化后的map
-
toIdentityMap
public static <V,K> Map<K,V> toIdentityMap(Collection<V> collection, Function<V, K> key, boolean isParallel) 将collection转化为类型不变的mapCollection<V> ----> Map<K,V>- Type Parameters:
V- collection中的泛型K- map中的key类型- Parameters:
collection- 需要转化的集合key- V类型转化为K类型的lambda方法isParallel- 是否并行流- Returns:
- 转化后的map
-
groupByKey
将collection按照规则(比如有相同的班级id)分类成mapCollection<E> -------> Map<K,List<E>>- Type Parameters:
E- collection中的泛型K- map中的key类型- Parameters:
collection- 需要分类的集合key- 键分组的规则- Returns:
- 分类后的map
-
groupByKey
public static <E,K> Map<K,List<E>> groupByKey(Collection<E> collection, Function<E, K> key, boolean isParallel) 将collection按照规则(比如有相同的班级id)分类成mapCollection<E> -------> Map<K,List<E>>- Type Parameters:
E- collection中的泛型K- map中的key类型- Parameters:
collection- 需要分类的集合key- 键分组的规则isParallel- 是否并行流- Returns:
- 分类后的map
-
groupBy2Key
public static <E,K, Map<K,U> Map<U, groupBy2KeyList<E>>> (Collection<E> collection, Function<E, K> key1, Function<E, U> key2) 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层mapCollection<E> ---> Map<T,Map<U,List<E>>>- Type Parameters:
E- 集合元素类型K- 第一个map中的key类型U- 第二个map中的key类型- Parameters:
collection- 需要分类的集合key1- 第一个分类的规则key2- 第二个分类的规则- Returns:
- 分类后的map
-
groupBy2Key
public static <E,K, Map<K,U> Map<U, groupBy2KeyList<E>>> (Collection<E> collection, Function<E, K> key1, Function<E, U> key2, boolean isParallel) 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层mapCollection<E> ---> Map<T,Map<U,List<E>>>- Type Parameters:
E- 集合元素类型K- 第一个map中的key类型U- 第二个map中的key类型- Parameters:
collection- 需要分类的集合key1- 第一个分类的规则key2- 第二个分类的规则isParallel- 是否并行流- Returns:
- 分类后的map
-
group2Map
public static <E,T, Map<T,U> Map<U, group2MapE>> (Collection<E> collection, Function<E, T> key1, Function<E, U> key2) 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层mapCollection<E> ---> Map<T,Map<U,E>>- Type Parameters:
E- collection中的泛型T- 第一个map中的key类型U- 第二个map中的key类型- Parameters:
collection- 需要分类的集合key1- 第一个分类的规则key2- 第二个分类的规则- Returns:
- 分类后的map
-
group2Map
public static <E,T, Map<T,U> Map<U, group2MapE>> (Collection<E> collection, Function<E, T> key1, Function<E, U> key2, boolean isParallel) 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层mapCollection<E> ---> Map<T,Map<U,E>>- Type Parameters:
E- collection中的泛型T- 第一个map中的key类型U- 第二个map中的key类型- Parameters:
collection- 需要分类的集合key1- 第一个分类的规则key2- 第二个分类的规则isParallel- 是否并行流- Returns:
- 分类后的map
-
groupKeyValue
public static <E,K, Map<K,V> List<V>> groupKeyValue(Collection<E> collection, Function<E, K> key, Function<E, V> value) 将collection按照规则(比如有相同的班级id)分类成map,map中的key为班级id,value为班级名Collection<E> -------> Map<K,List<V>>- Type Parameters:
E- collection中的泛型K- map中的key类型V- List中的value类型- Parameters:
collection- 需要分类的集合key- 分类的规则value- 分类的规则- Returns:
- 分类后的map
-
groupKeyValue
public static <E,K, Map<K,V> List<V>> groupKeyValue(Collection<E> collection, Function<E, K> key, Function<E, V> value, boolean isParallel) 将collection按照规则(比如有相同的班级id)分类成map,map中的key为班级id,value为班级名Collection<E> -------> Map<K,List<V>>- Type Parameters:
E- collection中的泛型K- map中的key类型V- List中的value类型- Parameters:
collection- 需要分类的集合key- 分类的规则value- 分类的规则isParallel- 是否并行流- Returns:
- 分类后的map
-
joining
-
joining
public static <T> Collector<T,?, joiningString> (CharSequence delimiter, Function<T, ? extends CharSequence> toStringFunc) 提供任意对象的Join操作的Collector实现- Type Parameters:
T- 对象类型- Parameters:
delimiter- 分隔符toStringFunc- 自定义指定对象转换为字符串的方法- Returns:
Collector
-
joining
public static <T> Collector<T,?, joiningString> (CharSequence delimiter, CharSequence prefix, CharSequence suffix, Function<T, ? extends CharSequence> toStringFunc) 提供任意对象的Join操作的Collector实现- Type Parameters:
T- 对象类型- Parameters:
delimiter- 分隔符prefix- 前缀suffix- 后缀toStringFunc- 自定义指定对象转换为字符串的方法- Returns:
Collector
-
groupingBy
-
groupingBy
public static <T,K, Collector<T,A, D> ?, groupingByMap<K, D>> (Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream) 提供对null值友好的groupingBy操作的Collector实现- Type Parameters:
T- 实体类型K- 实体中的分组依据对应类型,也是Map中key的类型A- 下游操作在进行中间操作时对应类型D- 下游操作对应返回类型,也是Map中value的类型- Parameters:
classifier- 分组依据downstream- 下游操作- Returns:
Collector
-
groupingBy
public static <T,K, Collector<T,D, A, M extends Map<K, D>> ?, groupingByM> (Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream) 提供对null值友好的groupingBy操作的Collector实现,可指定map类型- Type Parameters:
T- 实体类型K- 实体中的分组依据对应类型,也是Map中key的类型D- 下游操作对应返回类型,也是Map中value的类型A- 下游操作在进行中间操作时对应类型M- 最后返回结果Map类型- Parameters:
classifier- 分组依据mapFactory- 提供的mapdownstream- 下游操作- Returns:
Collector
-
groupingBy
public static <T,K, Collector<T,R> ?, groupingByMap<K, List<R>>> (Function<? super T, ? extends K> classifier, Function<? super T, ? extends R> valueMapper) 提供对null值友好的groupingBy操作的Collector实现, 对集合分组,然后对分组后的值集合进行映射- Type Parameters:
T- 元素类型K- 键类型R- 值类型- Parameters:
classifier- 分组依据valueMapper- 值映射方法- Returns:
Collector
-
groupingBy
public static <T,K, Collector<T,R, C extends Collection<R>> ?, groupingByMap<K, C>> (Function<? super T, ? extends K> classifier, Function<? super T, ? extends R> valueMapper, Supplier<C> valueCollFactory) 提供对null值友好的groupingBy操作的Collector实现, 对集合分组,然后对分组后的值集合进行映射- Type Parameters:
T- 元素类型K- 键类型R- 值类型C- 值集合类型- Parameters:
classifier- 分组依据valueMapper- 值映射方法valueCollFactory- 值集合的工厂方法- Returns:
Collector
-
groupingBy
public static <T,K, Collector<T,R, C extends Collection<R>, M extends Map<K, C>> ?, groupingByM> (Function<? super T, ? extends K> classifier, Function<? super T, ? extends R> valueMapper, Supplier<C> valueCollFactory, Supplier<M> mapFactory) 提供对null值友好的groupingBy操作的Collector实现, 对集合分组,然后对分组后的值集合进行映射- Type Parameters:
T- 元素类型K- 键类型R- 值类型C- 值集合类型M- 返回的Map集合类型- Parameters:
classifier- 分组依据valueMapper- 值映射方法valueCollFactory- 值集合的工厂方法mapFactory- Map集合的工厂方法- Returns:
Collector
-
mapMerger
public static <K,V, BinaryOperator<M> mapMergerM extends Map<K, V>> (BinaryOperator<V> mergeFunction) 用户合并map的BinaryOperator,传入合并前需要对value进行的操作- Type Parameters:
K- key的类型V- value的类型M- map- Parameters:
mergeFunction- 合并前需要对value进行的操作- Returns:
- 用户合并map的BinaryOperator
-
toList
将collection转化为List集合,但是两者的泛型不同Collection<E> ------> List<T>- Type Parameters:
E- collection中的泛型T- List中的泛型- Parameters:
collection- 需要转化的集合function- collection中的泛型转化为list泛型的lambda表达式- Returns:
- 转化后的list
-
toList
public static <E,T> List<T> toList(Collection<E> collection, Function<E, T> function, boolean isParallel) 将collection转化为List集合,但是两者的泛型不同Collection<E> ------> List<T>- Type Parameters:
E- collection中的泛型T- List中的泛型- Parameters:
collection- 需要转化的集合function- collection中的泛型转化为list泛型的lambda表达式isParallel- 是否并行流- Returns:
- 转化后的list
-
toSet
将collection转化为Set集合,但是两者的泛型不同Collection<E> ------> Set<T>- Type Parameters:
E- collection中的泛型T- Set中的泛型- Parameters:
collection- 需要转化的集合function- collection中的泛型转化为set泛型的lambda表达式- Returns:
- 转化后的Set
-
toSet
public static <E,T> Set<T> toSet(Collection<E> collection, Function<E, T> function, boolean isParallel) 将collection转化为Set集合,但是两者的泛型不同Collection<E> ------> Set<T>- Type Parameters:
E- collection中的泛型T- Set中的泛型- Parameters:
collection- 需要转化的集合function- collection中的泛型转化为set泛型的lambda表达式isParallel- 是否并行流- Returns:
- 转化后的Set
-
merge
合并两个相同key类型的map- Type Parameters:
K- map中的key类型X- 第一个 map的value类型Y- 第二个 map的value类型V- 最终map的value类型- Parameters:
map1- 第一个需要合并的 mapmap2- 第二个需要合并的 mapmerge- 合并的lambda,将key value1 value2合并成最终的类型,注意value可能为空的情况- Returns:
- 合并后的map
-
swapTo
-
swapElement
将指定元素交换到指定元素位置,其他元素的索引值不变 交换会修改原List如果集合中有多个相同元素,只交换第一个找到的元素- Type Parameters:
T- 处理参数类型- Parameters:
list- 列表element- 需交换元素targetElement- 目标元素
-
ringNextIntByObject
通过cas操作 实现对指定值内的回环累加- Parameters:
object- 集合- Collection - 集合的大小
- Map - Map的大小
- Array - 数组大小
- Iterator - 迭代器中剩余的元素数
- Enumeration - 枚举中剩余的元素数
atomicInteger- 原子操作类- Returns:
- 索引位置
-
ringNextInt
通过cas操作 实现对指定值内的回环累加- Parameters:
modulo- 回环周期值atomicInteger- 原子操作类- Returns:
- 索引位置
-
ringNextLong
通过cas操作 实现对指定值内的回环累加 此方法一般用于大量数据完成回环累加(如数据库中的值大于int最大值)- Parameters:
modulo- 回环周期值atomicLong- 原子操作类- Returns:
- 索引位置
-