CollUtil (hutool-码云(gitee.com))

java.lang.Object
- cn.hutool.core.collection.CollUtil

Direct Known Subclasses:

CollectionUtil
```
public class CollUtil
extends Object
```
集合相关工具类
此工具方法针对Collection及其实现类封装的工具。
由于Collection 实现了Iterable接口，因此部分工具此类不提供，而是在IterUtil 中提供

Since:

3.1.1

Author:

xiaoleilu

See Also:

IterUtil

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`CollUtil.Consumer<T>` 针对一个参数做相应的操作此函数接口与JDK8中Consumer不同是多提供了index参数，用于标记遍历对象是第几个。
`static interface`	`CollUtil.KVConsumer<K,V>` 针对两个参数做相应的操作，例如Map中的KEY和VALUE

Constructor Summary

Constructors
Constructor and Description

CollUtil()

Constructors
Constructor and Description
`CollUtil()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T> Collection<T>`	`addAll(Collection<T> collection, Enumeration<T> enumeration)` 加入全部
`static <T> Collection<T>`	`addAll(Collection<T> collection, Iterable<T> iterable)` 加入全部
`static <T> Collection<T>`	`addAll(Collection<T> collection, Iterator<T> iterator)` 加入全部
`static <T> Collection<T>`	`addAll(Collection<T> collection, Object value)` 将指定对象全部加入到集合中提供的对象如果为集合类型，会自动转换为目标元素类型
`static <T> Collection<T>`	`addAll(Collection<T> collection, Object value, Type elementType)` 将指定对象全部加入到集合中提供的对象如果为集合类型，会自动转换为目标元素类型如果为String，支持类似于[1,2,3,4] 或者 1,2,3,4 这种格式
`static <T> Collection<T>`	`addAll(Collection<T> collection, T[] values)` 加入全部
`static <T> List<T>`	`addAllIfNotContains(List<T> list, List<T> otherList)` 将另一个列表中的元素加入到列表中，如果列表中已经存在此元素则忽略之
`static <E> Enumeration<E>`	`asEnumeration(Iterator<E> iter)` Iterator转换为Enumeration
`static <E> Iterable<E>`	`asIterable(Iterator<E> iter)` `Iterator` 转为 `Iterable`
`static <E> Iterator<E>`	`asIterator(Enumeration<E> e)` Enumeration转换为Iterator
`static void`	`clear(Collection<?>... collections)` 清除一个或多个集合内的元素，每个集合调用clear()方法
`static boolean`	`contains(Collection<?> collection, Object value)` 判断指定集合是否包含指定值，如果集合为空（null或者空），返回`false`，否则找到元素返回`true`
`static <T> boolean`	`contains(Collection<T> collection, Predicate<? super T> containFunc)` 自定义函数判断集合是否包含某类值
`static boolean`	`containsAll(Collection<?> coll1, Collection<?> coll2)` 集合1中是否包含集合2中所有的元素，即集合2是否为集合1的子集
`static boolean`	`containsAny(Collection<?> coll1, Collection<?> coll2)` 其中一个集合在另一个集合中是否至少包含一个元素，即是两个集合是否至少有一个共同的元素
`static <T> int`	`count(Iterable<T> iterable, Matcher<T> matcher)` 集合中匹配规则的数量
`static <T> Map<T,Integer>`	`countMap(Iterable<T> collection)` 根据集合返回一个元素计数的 `Map` 所谓元素计数就是假如这个集合中某个元素出现了n次，那将这个元素做为key，n做为value 例如：[a,b,c,c,c] 得到： a: 1 b: 1 c: 3
`static <T> Collection<T>`	`create(Class<?> collectionType)` 创建新的集合对象
`static <K,V> Map<K,V>`	`createMap(Class<?> mapType)` 创建Map 传入AbstractMap和`Map`类将默认创建`HashMap`
`static <T extends Collection<E>,E> T`	`defaultIfEmpty(T collection, T defaultCollection)` 如果给定集合为空，返回默认集合
`static <T> Collection<T>`	`disjunction(Collection<T> coll1, Collection<T> coll2)` 两个集合的差集针对一个集合中存在多个相同元素的情况，计算两个集合中此元素的个数，保留两个集合中此元素个数差的个数例如：
`static <T> ArrayList<T>`	`distinct(Collection<T> collection)` 去重集合
`static <E,T extends Collection<E>> T`	`empty(Class<?> collectionClass)` 根据给定的集合类型，返回对应的空集合，支持类型包括： *
`static <T> List<T>`	`emptyIfNull(List<T> set)` 如果提供的集合为`null`，返回一个不可变的默认空集合，否则返回原集合空集合使用`Collections.emptyList()`
`static <T> Set<T>`	`emptyIfNull(Set<T> set)` 如果提供的集合为`null`，返回一个不可变的默认空集合，否则返回原集合空集合使用`Collections.emptySet()`
`static List<Object>`	`extract(Iterable<?> collection, Editor<Object> editor)` 通过Editor抽取集合元素中的某些值返回为新列表例如提供的是一个Bean列表，通过Editor接口实现获取某个字段值，返回这个字段值组成的新列表
`static List<Object>`	`extract(Iterable<?> collection, Editor<Object> editor, boolean ignoreNull)` 通过Editor抽取集合元素中的某些值返回为新列表例如提供的是一个Bean列表，通过Editor接口实现获取某个字段值，返回这个字段值组成的新列表
`static <K,V> Map<K,V>`	`fieldValueAsMap(Iterable<?> iterable, String fieldNameForKey, String fieldNameForValue)` 两个字段值组成新的Map
`static <K,V> Map<K,V>`	`fieldValueMap(Iterable<V> iterable, String fieldName)` 字段值与列表值对应的Map，常用于元素对象中有唯一ID时需要按照这个ID查找对象的情况例如：车牌号 =》车
`static <T> Collection<T>`	`filter(Collection<T> collection, Editor<T> editor)` 过滤，此方法产生一个新集合过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
`static <T> List<T>`	`filter(List<T> list, Editor<T> editor)` 过滤过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
`static <K,V> Map<K,V>`	`filter(Map<K,V> map, Editor<Map.Entry<K,V>> editor)` 过滤过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
`static <K,V> Map<K,V>`	`filter(Map<K,V> map, Filter<Map.Entry<K,V>> filter)` 过滤过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
`static <T extends Collection<E>,E> T`	`filter(T collection, Filter<E> filter)` 去除指定元素，此方法直接修改原集合
`static <T> Collection<T>`	`filterNew(Collection<T> collection, Filter<T> filter)` 过滤过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Filter实现可以实现以下功能：
`static <T> List<T>`	`filterNew(List<T> list, Filter<T> filter)` 过滤过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Filter实现可以实现以下功能：
`static <T> T`	`findOne(Iterable<T> collection, Filter<T> filter)` 查找第一个匹配元素对象
`static <T> T`	`findOneByField(Iterable<T> collection, String fieldName, Object fieldValue)` 查找第一个匹配元素对象如果集合元素是Map，则比对键和值是否相同，相同则返回如果为普通Bean，则通过反射比对元素字段名对应的字段值是否相同，相同则返回如果给定字段值参数是`null` 且元素对象中的字段值也为`null`则认为相同
`static <T> void`	`forEach(Enumeration<T> enumeration, CollUtil.Consumer<T> consumer)` 循环遍历 `Enumeration`，使用`CollUtil.Consumer` 接受遍历的每条数据，并针对每条数据做处理
`static <T> void`	`forEach(Iterable<T> iterable, CollUtil.Consumer<T> consumer)` 循环遍历 `Iterable`，使用`CollUtil.Consumer` 接受遍历的每条数据，并针对每条数据做处理
`static <T> void`	`forEach(Iterator<T> iterator, CollUtil.Consumer<T> consumer)` 循环遍历 `Iterator`，使用`CollUtil.Consumer` 接受遍历的每条数据，并针对每条数据做处理
`static <K,V> void`	`forEach(Map<K,V> map, CollUtil.KVConsumer<K,V> kvConsumer)` 循环遍历Map，使用`CollUtil.KVConsumer` 接受遍历的每条数据，并针对每条数据做处理和JDK8中的map.forEach不同的是，此方法支持index
`static <T> T`	`get(Collection<T> collection, int index)` 获取集合中指定下标的元素值，下标可以为负数，例如-1表示最后一个元素如果元素越界，返回null
`static <T> List<T>`	`getAny(Collection<T> collection, int... indexes)` 获取集合中指定多个下标的元素值，下标可以为负数，例如-1表示最后一个元素
`static Class<?>`	`getElementType(Iterable<?> iterable)` 获得`Iterable`对象的元素类型（通过第一个非空元素判断）
`static Class<?>`	`getElementType(Iterator<?> iterator)` 获得`Iterator`对象的元素类型（通过第一个非空元素判断）
`static List<Object>`	`getFieldValues(Iterable<?> collection, String fieldName)` 获取给定Bean列表中指定字段名对应字段值的列表列表元素支持Bean与Map
`static List<Object>`	`getFieldValues(Iterable<?> collection, String fieldName, boolean ignoreNull)` 获取给定Bean列表中指定字段名对应字段值的列表列表元素支持Bean与Map
`static <T> List<T>`	`getFieldValues(Iterable<?> collection, String fieldName, Class<T> elementType)` 获取给定Bean列表中指定字段名对应字段值的列表列表元素支持Bean与Map
`static <T> T`	`getFirst(Iterable<T> iterable)` 获取集合的第一个元素
`static <T> T`	`getFirst(Iterator<T> iterator)` 获取集合的第一个元素
`static <T> T`	`getLast(Collection<T> collection)` 获取集合的最后一个元素
`static <T> List<List<T>>`	`group(Collection<T> collection, Hash32<T> hash)` 分组，按照`Hash32`接口定义的hash算法，集合中的元素放入hash值对应的子列表中
`static <T> List<List<T>>`	`groupByField(Collection<T> collection, String fieldName)` 根据元素的指定字段名分组，非Bean都放在第一个分组中
`static boolean`	`hasNull(Iterable<?> iterable)` 是否包含`null`元素
`static <T> int[]`	`indexOfAll(Collection<T> collection, Matcher<T> matcher)` 获取匹配规则定义中匹配到元素的所有位置此方法对于某些无序集合的位置信息，以转换为数组后的位置为准。
`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]，此结果中只保留了两个c
`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
`static <T> Set<T>`	`intersectionDistinct(Collection<T> coll1, Collection<T> coll2, Collection<T>... otherColls)` 多个集合的交集针对一个集合中存在多个相同元素的情况，只保留一个例如：集合1：[a, b, c, c, c]，集合2：[a, b, c, c] 结果：[a, b, c]，此结果中只保留了一个c
`static boolean`	`isEmpty(Collection<?> collection)` 集合是否为空
`static boolean`	`isEmpty(Enumeration<?> enumeration)` Enumeration是否为空
`static boolean`	`isEmpty(Iterable<?> iterable)` Iterable是否为空
`static boolean`	`isEmpty(Iterator<?> Iterator)` Iterator是否为空
`static boolean`	`isEmpty(Map<?,?> map)` Map是否为空
`static boolean`	`isNotEmpty(Collection<?> collection)` 集合是否为非空
`static boolean`	`isNotEmpty(Enumeration<?> enumeration)` Enumeration是否为空
`static boolean`	`isNotEmpty(Iterable<?> iterable)` Iterable是否为空
`static boolean`	`isNotEmpty(Iterator<?> Iterator)` Iterator是否为空
`static boolean`	`isNotEmpty(Map<?,?> map)` Map是否为非空
`static <T> String`	`join(Iterable<T> iterable, CharSequence conjunction)` 以 conjunction 为分隔符将集合转换为字符串如果集合元素为数组、`Iterable`或`Iterator`，则递归组合其为字符串
`static <T> String`	`join(Iterable<T> iterable, CharSequence conjunction, String prefix, String suffix)` 以 conjunction 为分隔符将集合转换为字符串
`static <T> String`	`join(Iterator<T> iterator, CharSequence conjunction)` Deprecated. 请使用IterUtil#join(Iterator, CharSequence)
`static <K> Set<K>`	`keySet(Collection<Map<K,?>> mapCollection)` 获取指定Map列表中所有的Key
`static <T> List<T>`	`list(boolean isLinked)` 新建一个空List
`static <T> List<T>`	`list(boolean isLinked, Collection<T> collection)` 新建一个List
`static <T> List<T>`	`list(boolean isLinked, Enumeration<T> enumeration)` 新建一个List 提供的参数为null时返回空`ArrayList`
`static <T> List<T>`	`list(boolean isLinked, Iterable<T> iterable)` 新建一个List 提供的参数为null时返回空`ArrayList`
`static <T> List<T>`	`list(boolean isLinked, Iterator<T> iter)` 新建一个ArrayList 提供的参数为null时返回空`ArrayList`
`static <T> List<T>`	`list(boolean isLinked, T... values)` 新建一个List
`static <T,R> List<R>`	`map(Iterable<T> collection, Function<? super T,? extends R> func, boolean ignoreNull)` 通过func自定义一个规则，此规则将原集合中的元素转换成新的元素，生成新的列表返回例如提供的是一个Bean列表，通过Function接口实现获取某个字段值，返回这个字段值组成的新列表
`static <T extends Comparable<? super T>> T`	`max(Collection<T> coll)` 取最大值
`static <T extends Comparable<? super T>> T`	`min(Collection<T> coll)` 取最小值
`static <T> ArrayList<T>`	`newArrayList(Collection<T> collection)` 新建一个ArrayList
`static <T> ArrayList<T>`	`newArrayList(Enumeration<T> enumeration)` 新建一个ArrayList 提供的参数为null时返回空`ArrayList`
`static <T> ArrayList<T>`	`newArrayList(Iterable<T> iterable)` 新建一个ArrayList 提供的参数为null时返回空`ArrayList`
`static <T> ArrayList<T>`	`newArrayList(Iterator<T> iterator)` 新建一个ArrayList 提供的参数为null时返回空`ArrayList`
`static <T> ArrayList<T>`	`newArrayList(T... values)` 新建一个ArrayList
`static <T> BlockingQueue<T>`	`newBlockingQueue(int capacity, boolean isLinked)` 新建`BlockingQueue` 在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。
`static <T> CopyOnWriteArrayList<T>`	`newCopyOnWriteArrayList(Collection<T> collection)` 新建一个CopyOnWriteArrayList
`static <K,V> HashMap<K,V>`	`newHashMap()` 新建一个HashMap
`static <K,V> HashMap<K,V>`	`newHashMap(int size)` 新建一个HashMap
`static <K,V> HashMap<K,V>`	`newHashMap(int size, boolean isOrder)` 新建一个HashMap
`static <T> HashSet<T>`	`newHashSet(boolean isSorted, Collection<T> collection)` 新建一个HashSet
`static <T> HashSet<T>`	`newHashSet(boolean isSorted, Enumeration<T> enumeration)` 新建一个HashSet
`static <T> HashSet<T>`	`newHashSet(boolean isSorted, Iterator<T> iter)` 新建一个HashSet
`static <T> HashSet<T>`	`newHashSet(Collection<T> collection)` 新建一个HashSet
`static <T> HashSet<T>`	`newHashSet(T... ts)` 新建一个HashSet
`static <T> LinkedHashSet<T>`	`newLinkedHashSet(T... ts)` 新建一个LinkedHashSet
`static <T> LinkedList<T>`	`newLinkedList(T... values)` 新建LinkedList
`static <T> void`	`padLeft(List<T> list, int minLen, T padObj)` 填充List，以达到最小长度
`static <T> void`	`padRight(Collection<T> list, int minLen, T padObj)` 填充List，以达到最小长度
`static <T> List<T>`	`page(int pageNo, int pageSize, List<T> list)` 对指定List分页取值
`static <T> List<T>`	`popPart(Deque<T> surplusAlaDatas, int partSize)` 切取部分数据切取后的栈将减少这些元素
`static <T> List<T>`	`popPart(Stack<T> surplusAlaDatas, int partSize)` 切取部分数据切取后的栈将减少这些元素
`static <T extends Collection<E>,E> T`	`removeAny(T collection, E... elesRemoved)` 去掉集合中的多个元素，此方法直接修改原集合
`static <T extends Collection<E>,E extends CharSequence> T`	`removeBlank(T collection)` 去除`null`或者""或者空白字符串元素，此方法直接修改原集合
`static <T extends Collection<E>,E extends CharSequence> T`	`removeEmpty(T collection)` 去除`null`或者"" 元素，此方法直接修改原集合
`static <T extends Collection<E>,E> T`	`removeNull(T collection)` 去除`null` 元素，此方法直接修改原集合
`static <T> List<T>`	`reverse(List<T> list)` 反序给定List，会在原List基础上直接修改
`static <T> List<T>`	`reverseNew(List<T> list)` 反序给定List，会创建一个新的List，原List数据不变
`static <T> HashSet<T>`	`set(boolean isSorted, T... ts)` 新建一个HashSet
`static <T> List<T>`	`setOrAppend(List<T> list, int index, T element)` 设置或增加元素。当index小于List的长度时，替换指定位置的值，否则在尾部追加
`static int`	`size(Object object)` 获取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
`static <T> List<T>`	`sort(Collection<T> collection, Comparator<? super T> comparator)` 排序集合，排序不会修改原集合
`static <T> List<T>`	`sort(List<T> list, Comparator<? super T> c)` 针对List排序，排序会修改原List
`static <K,V> TreeMap<K,V>`	`sort(Map<K,V> map, Comparator<? super K> comparator)` 排序Map
`static <K,V> LinkedHashMap<K,V>`	`sortByEntry(Map<K,V> map, Comparator<Map.Entry<K,V>> comparator)` 通过Entry排序，可以按照键排序，也可以按照值排序，亦或者两者综合排序
`static List<String>`	`sortByPinyin(Collection<String> collection)` 根据汉字的拼音顺序排序
`static List<String>`	`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的属性排序
`static <K,V> List<Map.Entry<K,V>>`	`sortEntryToList(Collection<Map.Entry<K,V>> collection)` 将Set排序（根据Entry的值）
`static <T> List<T>`	`sortPageAll(int pageNo, int pageSize, Comparator<T> comparator, Collection<T>... colls)` 将多个集合排序并显示不同的段落（分页）采用`BoundedPriorityQueue`实现分页取局部
`static <K,V> LinkedHashMap<K,V>`	`sortToMap(Collection<Map.Entry<K,V>> entryCollection, Comparator<Map.Entry<K,V>> comparator)` 通过Entry排序，可以按照键排序，也可以按照值排序，亦或者两者综合排序
`static <T> List<List<T>>`	`split(Collection<T> collection, int size)` 对集合按照指定长度分段，每一个段为单独的集合，返回这个集合的列表
`static <T> List<List<T>>`	`splitList(List<T> list, int size)` 对集合按照指定长度分段，每一个段为单独的集合，返回这个集合的列表
`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>`	`sub(List<T> list, int start, int end)` 截取集合的部分
`static <T> List<T>`	`sub(List<T> list, int start, int end, int step)` 截取集合的部分
`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 <E> Collection<E>`	`toCollection(Iterable<E> iterable)` `Iterable`转为`Collection` 首先尝试强转，强转失败则构建一个新的`ArrayList`
`static <T> ArrayList<T>`	`toList(T... values)` 数组转为ArrayList
`static <K,V> Map<K,List<V>>`	`toListMap(Iterable<? extends Map<K,V>> mapList)` 行转列，合并相同的键，值合并为列表将Map列表中相同key的值组成列表做为Map的value 是`toMapList(Map)`的逆方法比如传入数据：
`static <K,V,E> Map<K,V>`	`toMap(Iterable<E> values, Map<K,V> map, Func1<E,K> keyFunc, Func1<E,V> valueFunc)` 集合转换为Map，转换规则为：按照keyFunc函数规则根据元素对象生成Key，按照valueFunc函数规则根据元素对象生成value组成新的Map
`static <K,V> HashMap<K,V>`	`toMap(Iterable<Map.Entry<K,V>> entryIter)` 将Entry集合转换为HashMap
`static <K,V> Map<K,V>`	`toMap(Iterable<V> values, Map<K,V> map, Func1<V,K> keyFunc)` 集合转换为Map，转换规则为：按照keyFunc函数规则根据元素对象生成Key，元素作为值
`static HashMap<Object,Object>`	`toMap(Object[] array)` 将数组转换为Map（HashMap），支持数组元素类型为：
`static <K,V> List<Map<K,V>>`	`toMapList(Map<K,? extends Iterable<V>> listMap)` 列转行。将Map中值列表分别按照其位置与key组成新的map。是`toListMap(Iterable)`的逆方法比如传入数据：
`static <T> TreeSet<T>`	`toTreeSet(Collection<T> collection, Comparator<T> comparator)` 将集合转换为排序后的TreeSet
`static <F,T> Collection<T>`	`trans(Collection<F> collection, Function<? super F,? extends T> function)` 使用给定的转换函数，转换源集合为新类型的集合
`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]，此结果中只保留了三个c
`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
`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]
`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
`static <T> Collection<T>`	`unmodifiable(Collection<? extends T> c)` 转为只读集合
`static <V> List<V>`	`values(Collection<Map<?,V>> mapCollection)` 获取指定Map列表中所有的Value
`static <K,V> ArrayList<V>`	`valuesOfKeys(Map<K,V> map, Iterable<K> keys)` 从Map中获取指定键列表对应的值列表如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
`static <K,V> ArrayList<V>`	`valuesOfKeys(Map<K,V> map, Iterator<K> keys)` 从Map中获取指定键列表对应的值列表如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
`static <K,V> ArrayList<V>`	`valuesOfKeys(Map<K,V> map, K... keys)` 从Map中获取指定键列表对应的值列表如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
`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} 如果两个数组长度不同，则只对应最短部分
`static Map<String,String>`	`zip(String keys, String values, String delimiter)` 映射键值（参考Python的zip()函数），返回Map无序例如： keys = a,b,c,d values = 1,2,3,4 delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分
`static Map<String,String>`	`zip(String keys, String values, String delimiter, boolean isOrder)` 映射键值（参考Python的zip()函数）例如： keys = a,b,c,d values = 1,2,3,4 delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分

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

- Constructor Detail
  - CollUtil
```
public CollUtil()
```
- Method Detail
  - emptyIfNull
```
public static <T> Set<T> emptyIfNull(Set<T> set)
```
    如果提供的集合为null，返回一个不可变的默认空集合，否则返回原集合
    空集合使用Collections.emptySet()
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    set - 提供的集合，可能为null
    
    Returns:
    
    原集合，若为null返回空集合
    
    Since:
    
    4.6.3
  - emptyIfNull
```
public static <T> List<T> emptyIfNull(List<T> set)
```
    如果提供的集合为null，返回一个不可变的默认空集合，否则返回原集合
    空集合使用Collections.emptyList()
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    set - 提供的集合，可能为null
    
    Returns:
    
    原集合，若为null返回空集合
    
    Since:
    
    4.6.3
  - union
```
public 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]，此结果中只保留了三个c
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    coll1 - 集合1
    
    coll2 - 集合2
    
    Returns:
    
    并集的集合，返回 ArrayList
  - union
```
@SafeVarargs
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 - 集合1
    
    coll2 - 集合2
    
    otherColls - 其它集合
    
    Returns:
    
    并集的集合，返回 ArrayList
  - unionDistinct
```
@SafeVarargs
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 - 集合1
    
    coll2 - 集合2
    
    otherColls - 其它集合
    
    Returns:
    
    并集的集合，返回 LinkedHashSet
  - unionAll
```
@SafeVarargs
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 - 集合1
    
    coll2 - 集合2
    
    otherColls - 其它集合
    
    Returns:
    
    并集的集合，返回 ArrayList
  - intersection
```
public 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]，此结果中只保留了两个c
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    coll1 - 集合1
    
    coll2 - 集合2
    
    Returns:
    
    交集的集合，返回 ArrayList
  - intersection
```
@SafeVarargs
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 - 集合1
    
    coll2 - 集合2
    
    otherColls - 其它集合
    
    Returns:
    
    并集的集合，返回 ArrayList
  - intersectionDistinct
```
@SafeVarargs
public static <T> Set<T> intersectionDistinct(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 - 集合1
    
    coll2 - 集合2
    
    otherColls - 其它集合
    
    Returns:
    
    并集的集合，返回 LinkedHashSet
    
    Since:
    
    5.3.9
  - disjunction
```
public static <T> Collection<T> disjunction(Collection<T> coll1,
                                            Collection<T> coll2)
```
    两个集合的差集
    针对一个集合中存在多个相同元素的情况，计算两个集合中此元素的个数，保留两个集合中此元素个数差的个数
    例如：
```
     disjunction([a, b, c, c, c], [a, b, c, c]) -》 [c]
     disjunction([a, b], [])                    -》 [a, b]
     disjunction([a, b, c], [b, c, d])          -》 [a, d]
 
```
    任意一个集合为空，返回另一个集合
    两个集合无差集则返回空集合
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    coll1 - 集合1
    
    coll2 - 集合2
    
    Returns:
    
    差集的集合，返回 ArrayList
  - subtract
```
public static <T> Collection<T> subtract(Collection<T> coll1,
                                         Collection<T> coll2)
```
    计算集合的单差集，即只返回【集合1】中有，但是【集合2】中没有的元素，例如：
```
     subtract([1,2,3,4],[2,3,4,5]) -》 [1]
 
```
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    coll1 - 集合1
    
    coll2 - 集合2
    
    Returns:
    
    单差集
  - subtractToList
```
public static <T> List<T> subtractToList(Collection<T> coll1,
                                         Collection<T> coll2)
```
    计算集合的单差集，即只返回【集合1】中有，但是【集合2】中没有的元素，例如：
```
     subtractToList([1,2,3,4],[2,3,4,5]) -》 [1]
 
```
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    coll1 - 集合1
    
    coll2 - 集合2
    
    Returns:
    
    单差集
    
    Since:
    
    5.3.5
  - contains
```
public static boolean contains(Collection<?> collection,
                               Object value)
```
    判断指定集合是否包含指定值，如果集合为空（null或者空），返回false，否则找到元素返回true
    
    Parameters:
    
    collection - 集合
    
    value - 需要查找的值
    
    Returns:
    
    如果集合为空（null或者空），返回false，否则找到元素返回true
    
    Since:
    
    4.1.10
  - contains
```
public static <T> boolean contains(Collection<T> collection,
                                   Predicate<? super T> containFunc)
```
    自定义函数判断集合是否包含某类值
    
    Type Parameters:
    
    T - 值类型
    
    Parameters:
    
    collection - 集合
    
    containFunc - 自定义判断函数
    
    Returns:
    
    是否包含自定义规则的值
  - containsAny
```
public static boolean containsAny(Collection<?> coll1,
                                  Collection<?> coll2)
```
    其中一个集合在另一个集合中是否至少包含一个元素，即是两个集合是否至少有一个共同的元素
    
    Parameters:
    
    coll1 - 集合1
    
    coll2 - 集合2
    
    Returns:
    
    其中一个集合在另一个集合中是否至少包含一个元素
    
    Since:
    
    2.1
    
    See Also:
    
    intersection(java.util.Collection<T>, java.util.Collection<T>)
  - containsAll
```
public static boolean containsAll(Collection<?> coll1,
                                  Collection<?> coll2)
```
    集合1中是否包含集合2中所有的元素，即集合2是否为集合1的子集
    
    Parameters:
    
    coll1 - 集合1
    
    coll2 - 集合2
    
    Returns:
    
    集合1中是否包含集合2中所有的元素
    
    Since:
    
    4.5.12
  - countMap
```
public static <T> Map<T,Integer> countMap(Iterable<T> collection)
```
    根据集合返回一个元素计数的 Map
    所谓元素计数就是假如这个集合中某个元素出现了n次，那将这个元素做为key，n做为value
    例如：[a,b,c,c,c] 得到：
    a: 1
    b: 1
    c: 3
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    Returns:
    
    Map
    
    See Also:
    
    IterUtil.countMap(Iterator)
  - join
```
public static <T> String join(Iterable<T> iterable,
                              CharSequence conjunction)
```
    以 conjunction 为分隔符将集合转换为字符串
    如果集合元素为数组、Iterable或Iterator，则递归组合其为字符串
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterable - Iterable
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
    
    See Also:
    
    IterUtil.join(Iterator, CharSequence)
  - join
```
public static <T> String join(Iterable<T> iterable,
                              CharSequence conjunction,
                              String prefix,
                              String suffix)
```
    以 conjunction 为分隔符将集合转换为字符串
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterable - Iterable
    
    conjunction - 分隔符
    
    prefix - 每个元素添加的前缀，null表示不添加
    
    suffix - 每个元素添加的后缀，null表示不添加
    
    Returns:
    
    连接后的字符串
    
    Since:
    
    5.3.0
  - join
```
@Deprecated
public static <T> String join(Iterator<T> iterator,
                                          CharSequence conjunction)
```
    Deprecated. 请使用IterUtil#join(Iterator, CharSequence)
    
    以 conjunction 为分隔符将集合转换为字符串
    如果集合元素为数组、Iterable或Iterator，则递归组合其为字符串
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterator - 集合
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - popPart
```
public static <T> List<T> popPart(Stack<T> surplusAlaDatas,
                                  int partSize)
```
    切取部分数据
    切取后的栈将减少这些元素
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    surplusAlaDatas - 原数据
    
    partSize - 每部分数据的长度
    
    Returns:
    
    切取出的数据或null
  - popPart
```
public static <T> List<T> popPart(Deque<T> surplusAlaDatas,
                                  int partSize)
```
    切取部分数据
    切取后的栈将减少这些元素
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    surplusAlaDatas - 原数据
    
    partSize - 每部分数据的长度
    
    Returns:
    
    切取出的数据或null
  - newHashMap
```
public static <K,V> HashMap<K,V> newHashMap()
```
    新建一个HashMap
    
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Returns:
    
    HashMap对象
    
    See Also:
    
    MapUtil.newHashMap()
  - newHashMap
```
public static <K,V> HashMap<K,V> newHashMap(int size,
                                            boolean isOrder)
```
    新建一个HashMap
    
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Parameters:
    
    size - 初始大小，由于默认负载因子0.75，传入的size会实际初始大小为size / 0.75
    
    isOrder - Map的Key是否有序，有序返回 LinkedHashMap，否则返回 HashMap
    
    Returns:
    
    HashMap对象
    
    Since:
    
    3.0.4
    
    See Also:
    
    MapUtil.newHashMap(int, boolean)
  - newHashMap
```
public static <K,V> HashMap<K,V> newHashMap(int size)
```
    新建一个HashMap
    
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Parameters:
    
    size - 初始大小，由于默认负载因子0.75，传入的size会实际初始大小为size / 0.75
    
    Returns:
    
    HashMap对象
    
    See Also:
    
    MapUtil.newHashMap(int)
  - newHashSet
```
@SafeVarargs
public static <T> HashSet<T> newHashSet(T... ts)
```
    新建一个HashSet
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    ts - 元素数组
    
    Returns:
    
    HashSet对象
  - newLinkedHashSet
```
@SafeVarargs
public static <T> LinkedHashSet<T> newLinkedHashSet(T... ts)
```
    新建一个LinkedHashSet
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    ts - 元素数组
    
    Returns:
    
    HashSet对象
    
    Since:
    
    4.1.10
  - set
```
@SafeVarargs
public static <T> HashSet<T> set(boolean isSorted,
                                              T... ts)
```
    新建一个HashSet
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    isSorted - 是否有序，有序返回 LinkedHashSet，否则返回 HashSet
    
    ts - 元素数组
    
    Returns:
    
    HashSet对象
  - newHashSet
```
public static <T> HashSet<T> newHashSet(Collection<T> collection)
```
    新建一个HashSet
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    Returns:
    
    HashSet对象
  - newHashSet
```
public static <T> HashSet<T> newHashSet(boolean isSorted,
                                        Collection<T> collection)
```
    新建一个HashSet
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    isSorted - 是否有序，有序返回 LinkedHashSet，否则返回HashSet
    
    collection - 集合，用于初始化Set
    
    Returns:
    
    HashSet对象
  - newHashSet
```
public static <T> HashSet<T> newHashSet(boolean isSorted,
                                        Iterator<T> iter)
```
    新建一个HashSet
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    isSorted - 是否有序，有序返回 LinkedHashSet，否则返回HashSet
    
    iter - Iterator
    
    Returns:
    
    HashSet对象
    
    Since:
    
    3.0.8
  - newHashSet
```
public static <T> HashSet<T> newHashSet(boolean isSorted,
                                        Enumeration<T> enumeration)
```
    新建一个HashSet
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    isSorted - 是否有序，有序返回 LinkedHashSet，否则返回HashSet
    
    enumeration - Enumeration
    
    Returns:
    
    HashSet对象
    
    Since:
    
    3.0.8
  - list
```
public static <T> List<T> list(boolean isLinked)
```
    新建一个空List
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    isLinked - 是否新建LinkedList
    
    Returns:
    
    List对象
    
    Since:
    
    4.1.2
  - list
```
@SafeVarargs
public static <T> List<T> list(boolean isLinked,
                                            T... values)
```
    新建一个List
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    isLinked - 是否新建LinkedList
    
    values - 数组
    
    Returns:
    
    List对象
    
    Since:
    
    4.1.2
  - list
```
public static <T> List<T> list(boolean isLinked,
                               Collection<T> collection)
```
    新建一个List
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    isLinked - 是否新建LinkedList
    
    collection - 集合
    
    Returns:
    
    List对象
    
    Since:
    
    4.1.2
  - list
```
public static <T> List<T> list(boolean isLinked,
                               Iterable<T> iterable)
```
    新建一个List
    提供的参数为null时返回空ArrayList
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    isLinked - 是否新建LinkedList
    
    iterable - Iterable
    
    Returns:
    
    List对象
    
    Since:
    
    4.1.2
  - list
```
public static <T> List<T> list(boolean isLinked,
                               Iterator<T> iter)
```
    新建一个ArrayList
    提供的参数为null时返回空ArrayList
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    isLinked - 是否新建LinkedList
    
    iter - Iterator
    
    Returns:
    
    ArrayList对象
    
    Since:
    
    4.1.2
  - list
```
public static <T> List<T> list(boolean isLinked,
                               Enumeration<T> enumeration)
```
    新建一个List
    提供的参数为null时返回空ArrayList
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    isLinked - 是否新建LinkedList
    
    enumeration - Enumeration
    
    Returns:
    
    ArrayList对象
    
    Since:
    
    3.0.8
  - newArrayList
```
@SafeVarargs
public static <T> ArrayList<T> newArrayList(T... values)
```
    新建一个ArrayList
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    values - 数组
    
    Returns:
    
    ArrayList对象
    
    See Also:
    
    toList(Object[])
  - toList
```
@SafeVarargs
public static <T> ArrayList<T> toList(T... values)
```
    数组转为ArrayList
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    values - 数组
    
    Returns:
    
    ArrayList对象
    
    Since:
    
    4.0.11
  - newArrayList
```
public static <T> ArrayList<T> newArrayList(Collection<T> collection)
```
    新建一个ArrayList
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    Returns:
    
    ArrayList对象
  - newArrayList
```
public static <T> ArrayList<T> newArrayList(Iterable<T> iterable)
```
    新建一个ArrayList
    提供的参数为null时返回空ArrayList
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterable - Iterable
    
    Returns:
    
    ArrayList对象
    
    Since:
    
    3.1.0
  - newArrayList
```
public static <T> ArrayList<T> newArrayList(Iterator<T> iterator)
```
    新建一个ArrayList
    提供的参数为null时返回空ArrayList
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterator - Iterator
    
    Returns:
    
    ArrayList对象
    
    Since:
    
    3.0.8
  - newArrayList
```
public static <T> ArrayList<T> newArrayList(Enumeration<T> enumeration)
```
    新建一个ArrayList
    提供的参数为null时返回空ArrayList
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    enumeration - Enumeration
    
    Returns:
    
    ArrayList对象
    
    Since:
    
    3.0.8
  - newLinkedList
```
@SafeVarargs
public static <T> LinkedList<T> newLinkedList(T... values)
```
    新建LinkedList
    
    Type Parameters:
    
    T - 类型
    
    Parameters:
    
    values - 数组
    
    Returns:
    
    LinkedList
    
    Since:
    
    4.1.2
  - newCopyOnWriteArrayList
```
public static <T> CopyOnWriteArrayList<T> newCopyOnWriteArrayList(Collection<T> collection)
```
    新建一个CopyOnWriteArrayList
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    Returns:
    
    CopyOnWriteArrayList
  - newBlockingQueue
```
public static <T> BlockingQueue<T> newBlockingQueue(int capacity,
                                                    boolean isLinked)
```
    新建BlockingQueue
    在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。
    
    Type Parameters:
    
    T - 集合类型
    
    Parameters:
    
    capacity - 容量
    
    isLinked - 是否为链表形式
    
    Returns:
    
    BlockingQueue
    
    Since:
    
    3.3.0
  - create
```
public static <T> Collection<T> create(Class<?> collectionType)
```
    创建新的集合对象
    
    Type Parameters:
    
    T - 集合类型
    
    Parameters:
    
    collectionType - 集合类型
    
    Returns:
    
    集合类型对应的实例
    
    Since:
    
    3.0.8
  - createMap
```
public static <K,V> Map<K,V> createMap(Class<?> mapType)
```
    创建Map
    传入AbstractMap和Map类将默认创建HashMap
    
    Type Parameters:
    
    K - map键类型
    
    V - map值类型
    
    Parameters:
    
    mapType - map类型
    
    Returns:
    
    Map实例
    
    See Also:
    
    MapUtil.createMap(Class)
  - distinct
```
public static <T> ArrayList<T> distinct(Collection<T> collection)
```
    去重集合
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    Returns:
    
    ArrayList
  - sub
```
public static <T> List<T> sub(List<T> list,
                              int start,
                              int end)
```
    截取集合的部分
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    list - 被截取的数组
    
    start - 开始位置（包含）
    
    end - 结束位置（不包含）
    
    Returns:
    
    截取后的数组，当开始位置超过最大时，返回空的List
  - sub
```
public static <T> List<T> sub(List<T> list,
                              int start,
                              int end,
                              int step)
```
    截取集合的部分
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    list - 被截取的数组
    
    start - 开始位置（包含）
    
    end - 结束位置（不包含）
    
    step - 步进
    
    Returns:
    
    截取后的数组，当开始位置超过最大时，返回空的List
    
    Since:
    
    4.0.6
  - sub
```
public static <T> List<T> sub(Collection<T> collection,
                              int start,
                              int end)
```
    截取集合的部分
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 被截取的数组
    
    start - 开始位置（包含）
    
    end - 结束位置（不包含）
    
    Returns:
    
    截取后的数组，当开始位置超过最大时，返回null
  - sub
```
public static <T> List<T> sub(Collection<T> list,
                              int start,
                              int end,
                              int step)
```
    截取集合的部分
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    list - 被截取的数组
    
    start - 开始位置（包含）
    
    end - 结束位置（不包含）
    
    step - 步进
    
    Returns:
    
    截取后的数组，当开始位置超过最大时，返回空集合
    
    Since:
    
    4.0.6
  - splitList
```
public static <T> List<List<T>> splitList(List<T> list,
                                          int size)
```
    对集合按照指定长度分段，每一个段为单独的集合，返回这个集合的列表
    需要特别注意的是，此方法调用List.subList(int, int)切分List，此方法返回的是原List的视图，也就是说原List有变更，切分后的结果也会变更。
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    list - 列表
    
    size - 每个段的长度
    
    Returns:
    
    分段列表
    
    Since:
    
    5.4.5
  - split
```
public static <T> List<List<T>> split(Collection<T> collection,
                                      int size)
```
    对集合按照指定长度分段，每一个段为单独的集合，返回这个集合的列表
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    size - 每个段的长度
    
    Returns:
    
    分段列表
  - filter
```
public static <T> Collection<T> filter(Collection<T> collection,
                                       Editor<T> editor)
```
    过滤，此方法产生一个新集合
    过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
```
 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
 2、修改元素对象，返回集合中为修改后的对象
 
```
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    editor - 编辑器接口
    
    Returns:
    
    过滤后的集合
  - filter
```
public static <T> List<T> filter(List<T> list,
                                 Editor<T> editor)
```
    过滤
    过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
```
 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
 2、修改元素对象，返回集合中为修改后的对象
 
```
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    list - 集合
    
    editor - 编辑器接口
    
    Returns:
    
    过滤后的数组
    
    Since:
    
    4.1.8
  - filterNew
```
public static <T> Collection<T> filterNew(Collection<T> collection,
                                          Filter<T> filter)
```
    过滤
    过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Filter实现可以实现以下功能：
```
 1、过滤出需要的对象，Filter.accept(Object)方法返回true的对象将被加入结果集合中
 
```
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    filter - 过滤器
    
    Returns:
    
    过滤后的数组
    
    Since:
    
    3.1.0
  - filterNew
```
public static <T> List<T> filterNew(List<T> list,
                                    Filter<T> filter)
```
    过滤
    过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Filter实现可以实现以下功能：
```
 1、过滤出需要的对象，Filter.accept(Object)方法返回true的对象将被加入结果集合中
 
```
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    list - 集合
    
    filter - 过滤器
    
    Returns:
    
    过滤后的数组
    
    Since:
    
    4.1.8
  - removeAny
```
public static <T extends Collection<E>,E> T removeAny(T collection,
                                                      E... elesRemoved)
```
    去掉集合中的多个元素，此方法直接修改原集合
    
    Type Parameters:
    
    T - 集合类型
    
    E - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    elesRemoved - 被去掉的元素数组
    
    Returns:
    
    原集合
    
    Since:
    
    4.1.0
  - filter
```
public static <T extends Collection<E>,E> T filter(T collection,
                                                   Filter<E> filter)
```
    去除指定元素，此方法直接修改原集合
    
    Type Parameters:
    
    T - 集合类型
    
    E - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    filter - 过滤器
    
    Returns:
    
    处理后的集合
    
    Since:
    
    4.6.5
  - removeNull
```
public static <T extends Collection<E>,E> T removeNull(T collection)
```
    去除null 元素，此方法直接修改原集合
    
    Type Parameters:
    
    T - 集合类型
    
    E - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    Returns:
    
    处理后的集合
    
    Since:
    
    3.2.2
  - removeEmpty
```
public static <T extends Collection<E>,E extends CharSequence> T removeEmpty(T collection)
```
    去除null或者"" 元素，此方法直接修改原集合
    
    Type Parameters:
    
    T - 集合类型
    
    E - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    Returns:
    
    处理后的集合
    
    Since:
    
    3.2.2
  - removeBlank
```
public static <T extends Collection<E>,E extends CharSequence> T removeBlank(T collection)
```
    去除null或者""或者空白字符串元素，此方法直接修改原集合
    
    Type Parameters:
    
    T - 集合类型
    
    E - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    Returns:
    
    处理后的集合
    
    Since:
    
    3.2.2
  - extract
```
public static List<Object> extract(Iterable<?> collection,
                                   Editor<Object> editor)
```
    通过Editor抽取集合元素中的某些值返回为新列表
    例如提供的是一个Bean列表，通过Editor接口实现获取某个字段值，返回这个字段值组成的新列表
    
    Parameters:
    
    collection - 原集合
    
    editor - 编辑器
    
    Returns:
    
    抽取后的新列表
  - extract
```
public static List<Object> extract(Iterable<?> collection,
                                   Editor<Object> editor,
                                   boolean ignoreNull)
```
    通过Editor抽取集合元素中的某些值返回为新列表
    例如提供的是一个Bean列表，通过Editor接口实现获取某个字段值，返回这个字段值组成的新列表
    
    Parameters:
    
    collection - 原集合
    
    editor - 编辑器
    
    ignoreNull - 是否忽略空值
    
    Returns:
    
    抽取后的新列表
    
    Since:
    
    4.5.7
    
    See Also:
    
    map(Iterable, Function, boolean)
  - 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:
    
    抽取后的新列表
    
    Since:
    
    5.3.5
  - getFieldValues
```
public static List<Object> getFieldValues(Iterable<?> collection,
                                          String fieldName)
```
    获取给定Bean列表中指定字段名对应字段值的列表
    列表元素支持Bean与Map
    
    Parameters:
    
    collection - Bean集合或Map集合
    
    fieldName - 字段名或map的键
    
    Returns:
    
    字段值列表
    
    Since:
    
    3.1.0
  - getFieldValues
```
public static List<Object> getFieldValues(Iterable<?> collection,
                                          String fieldName,
                                          boolean ignoreNull)
```
    获取给定Bean列表中指定字段名对应字段值的列表
    列表元素支持Bean与Map
    
    Parameters:
    
    collection - Bean集合或Map集合
    
    fieldName - 字段名或map的键
    
    ignoreNull - 是否忽略值为null的字段
    
    Returns:
    
    字段值列表
    
    Since:
    
    4.5.7
  - getFieldValues
```
public static <T> List<T> getFieldValues(Iterable<?> collection,
                                         String fieldName,
                                         Class<T> elementType)
```
    获取给定Bean列表中指定字段名对应字段值的列表
    列表元素支持Bean与Map
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    collection - Bean集合或Map集合
    
    fieldName - 字段名或map的键
    
    elementType - 元素类型类
    
    Returns:
    
    字段值列表
    
    Since:
    
    4.5.6
  - fieldValueMap
```
public static <K,V> Map<K,V> fieldValueMap(Iterable<V> iterable,
                                           String fieldName)
```
    字段值与列表值对应的Map，常用于元素对象中有唯一ID时需要按照这个ID查找对象的情况
    例如：车牌号 =》车
    
    Type Parameters:
    
    K - 字段名对应值得类型，不确定请使用Object
    
    V - 对象类型
    
    Parameters:
    
    iterable - 对象列表
    
    fieldName - 字段名（会通过反射获取其值）
    
    Returns:
    
    某个字段值与对象对应Map
    
    Since:
    
    5.0.6
  - fieldValueAsMap
```
public static <K,V> Map<K,V> fieldValueAsMap(Iterable<?> iterable,
                                             String fieldNameForKey,
                                             String fieldNameForValue)
```
    两个字段值组成新的Map
    
    Type Parameters:
    
    K - 字段名对应值得类型，不确定请使用Object
    
    V - 值类型，不确定使用Object
    
    Parameters:
    
    iterable - 对象列表
    
    fieldNameForKey - 做为键的字段名（会通过反射获取其值）
    
    fieldNameForValue - 做为值的字段名（会通过反射获取其值）
    
    Returns:
    
    某个字段值与对象对应Map
    
    Since:
    
    5.0.6
  - findOne
```
public static <T> T findOne(Iterable<T> collection,
                            Filter<T> filter)
```
    查找第一个匹配元素对象
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    filter - 过滤器，满足过滤条件的第一个元素将被返回
    
    Returns:
    
    满足过滤条件的第一个元素
    
    Since:
    
    3.1.0
  - findOneByField
```
public static <T> T findOneByField(Iterable<T> collection,
                                   String fieldName,
                                   Object fieldValue)
```
    查找第一个匹配元素对象
    如果集合元素是Map，则比对键和值是否相同，相同则返回
    如果为普通Bean，则通过反射比对元素字段名对应的字段值是否相同，相同则返回
    如果给定字段值参数是null 且元素对象中的字段值也为null则认为相同
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合，集合元素可以是Bean或者Map
    
    fieldName - 集合元素对象的字段名或map的键
    
    fieldValue - 集合元素对象的字段值或map的值
    
    Returns:
    
    满足条件的第一个元素
    
    Since:
    
    3.1.0
  - filter
```
public static <K,V> Map<K,V> filter(Map<K,V> map,
                                    Editor<Map.Entry<K,V>> editor)
```
    过滤
    过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
```
 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
 2、修改元素对象，返回集合中为修改后的对象
 
```
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Parameters:
    
    map - Map
    
    editor - 编辑器接口
    
    Returns:
    
    过滤后的Map
    
    See Also:
    
    MapUtil.filter(Map, Editor)
  - filter
```
public static <K,V> Map<K,V> filter(Map<K,V> map,
                                    Filter<Map.Entry<K,V>> filter)
```
    过滤
    过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
```
 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
 2、修改元素对象，返回集合中为修改后的对象
 
```
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Parameters:
    
    map - Map
    
    filter - 编辑器接口
    
    Returns:
    
    过滤后的Map
    
    Since:
    
    3.1.0
    
    See Also:
    
    MapUtil.filter(Map, Filter)
  - count
```
public static <T> int count(Iterable<T> iterable,
                            Matcher<T> matcher)
```
    集合中匹配规则的数量
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterable - Iterable
    
    matcher - 匹配器，为空则全部匹配
    
    Returns:
    
    匹配数量
  - indexOfAll
```
public static <T> int[] indexOfAll(Collection<T> collection,
                                   Matcher<T> matcher)
```
    获取匹配规则定义中匹配到元素的所有位置
    此方法对于某些无序集合的位置信息，以转换为数组后的位置为准。
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    collection - 集合
    
    matcher - 匹配器，为空则全部匹配
    
    Returns:
    
    位置数组
    
    Since:
    
    5.2.5
  - isEmpty
```
public static boolean isEmpty(Collection<?> collection)
```
    集合是否为空
    
    Parameters:
    
    collection - 集合
    
    Returns:
    
    是否为空
  - defaultIfEmpty
```
public static <T extends Collection<E>,E> T defaultIfEmpty(T collection,
                                                           T defaultCollection)
```
    如果给定集合为空，返回默认集合
    
    Type Parameters:
    
    T - 集合类型
    
    E - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    defaultCollection - 默认数组
    
    Returns:
    
    非空（empty）的原集合或默认集合
    
    Since:
    
    4.6.9
  - isEmpty
```
public static boolean isEmpty(Map<?,?> map)
```
    Map是否为空
    
    Parameters:
    
    map - 集合
    
    Returns:
    
    是否为空
    
    See Also:
    
    MapUtil.isEmpty(Map)
  - isEmpty
```
public static boolean isEmpty(Iterable<?> iterable)
```
    Iterable是否为空
    
    Parameters:
    
    iterable - Iterable对象
    
    Returns:
    
    是否为空
    
    See Also:
    
    IterUtil.isEmpty(Iterable)
  - isEmpty
```
public static boolean isEmpty(Iterator<?> Iterator)
```
    Iterator是否为空
    
    Parameters:
    
    Iterator - Iterator对象
    
    Returns:
    
    是否为空
    
    See Also:
    
    IterUtil.isEmpty(Iterator)
  - isEmpty
```
public static boolean isEmpty(Enumeration<?> enumeration)
```
    Enumeration是否为空
    
    Parameters:
    
    enumeration - Enumeration
    
    Returns:
    
    是否为空
  - isNotEmpty
```
public static boolean isNotEmpty(Collection<?> collection)
```
    集合是否为非空
    
    Parameters:
    
    collection - 集合
    
    Returns:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(Map<?,?> map)
```
    Map是否为非空
    
    Parameters:
    
    map - 集合
    
    Returns:
    
    是否为非空
    
    See Also:
    
    MapUtil.isNotEmpty(Map)
  - isNotEmpty
```
public static boolean isNotEmpty(Iterable<?> iterable)
```
    Iterable是否为空
    
    Parameters:
    
    iterable - Iterable对象
    
    Returns:
    
    是否为空
    
    See Also:
    
    IterUtil.isNotEmpty(Iterable)
  - isNotEmpty
```
public static boolean isNotEmpty(Iterator<?> Iterator)
```
    Iterator是否为空
    
    Parameters:
    
    Iterator - Iterator对象
    
    Returns:
    
    是否为空
    
    See Also:
    
    IterUtil.isNotEmpty(Iterator)
  - isNotEmpty
```
public static boolean isNotEmpty(Enumeration<?> enumeration)
```
    Enumeration是否为空
    
    Parameters:
    
    enumeration - Enumeration
    
    Returns:
    
    是否为空
  - hasNull
```
public static boolean hasNull(Iterable<?> iterable)
```
    是否包含null元素
    
    Parameters:
    
    iterable - 被检查的Iterable对象，如果为null 返回true
    
    Returns:
    
    是否包含null元素
    
    Since:
    
    3.0.7
    
    See Also:
    
    IterUtil.hasNull(Iterable)
  - zip
```
public static Map<String,String> zip(String keys,
                                     String values,
                                     String delimiter,
                                     boolean isOrder)
```
    映射键值（参考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
    
    Since:
    
    3.0.4
  - zip
```
public static Map<String,String> zip(String keys,
                                     String values,
                                     String delimiter)
```
    映射键值（参考Python的zip()函数），返回Map无序
    例如：
    keys = a,b,c,d
    values = 1,2,3,4
    delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4}
    如果两个数组长度不同，则只对应最短部分
    
    Parameters:
    
    keys - 键列表
    
    values - 值列表
    
    delimiter - 分隔符
    
    Returns:
    
    Map
  - zip
```
public 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}
    如果两个数组长度不同，则只对应最短部分
    
    Type Parameters:
    
    K - 键类型
    
    V - 值类型
    
    Parameters:
    
    keys - 键列表
    
    values - 值列表
    
    Returns:
    
    Map
  - toMap
```
public static <K,V> HashMap<K,V> toMap(Iterable<Map.Entry<K,V>> entryIter)
```
    将Entry集合转换为HashMap
    
    Type Parameters:
    
    K - 键类型
    
    V - 值类型
    
    Parameters:
    
    entryIter - entry集合
    
    Returns:
    
    Map
    
    See Also:
    
    IterUtil.toMap(Iterable)
  - toMap
```
public static HashMap<Object,Object> toMap(Object[] array)
```
    将数组转换为Map（HashMap），支持数组元素类型为：
```
 Map.Entry
 长度大于1的数组（取前两个值），如果不满足跳过此元素
 Iterable 长度也必须大于1（取前两个值），如果不满足跳过此元素
 Iterator 长度也必须大于1（取前两个值），如果不满足跳过此元素
 
```
```
 Map<Object, Object> colorMap = CollectionUtil.toMap(new String[][] {{
     {"RED", "#FF0000"},
     {"GREEN", "#00FF00"},
     {"BLUE", "#0000FF"}});
 
```
    参考：commons-lang
    Parameters:
    
    array - 数组。元素类型为Map.Entry、数组、Iterable、Iterator
    
    Returns:
    
    HashMap
    
    Since:
    
    3.0.8
    
    See Also:
    
    MapUtil.of(Object[])
  - toTreeSet
```
public static <T> TreeSet<T> toTreeSet(Collection<T> collection,
                                       Comparator<T> comparator)
```
    将集合转换为排序后的TreeSet
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    comparator - 比较器
    
    Returns:
    
    treeSet
  - asEnumeration
```
public static <E> Enumeration<E> asEnumeration(Iterator<E> iter)
```
    Iterator转换为Enumeration
    Adapt the specified Iterator to the Enumeration interface.
    
    Type Parameters:
    
    E - 集合元素类型
    
    Parameters:
    
    iter - Iterator
    
    Returns:
    
    Enumeration
  - asIterator
```
public static <E> Iterator<E> asIterator(Enumeration<E> e)
```
    Enumeration转换为Iterator
    Adapt the specified Enumeration to the Iterator interface
    
    Type Parameters:
    
    E - 集合元素类型
    
    Parameters:
    
    e - Enumeration
    
    Returns:
    
    Iterator
    
    See Also:
    
    IterUtil.asIterator(Enumeration)
  - asIterable
```
public static <E> Iterable<E> asIterable(Iterator<E> iter)
```
    Iterator 转为 Iterable
    
    Type Parameters:
    
    E - 元素类型
    
    Parameters:
    
    iter - Iterator
    
    Returns:
    
    Iterable
    
    See Also:
    
    IterUtil.asIterable(Iterator)
  - toCollection
```
public static <E> Collection<E> toCollection(Iterable<E> iterable)
```
    Iterable转为Collection
    首先尝试强转，强转失败则构建一个新的ArrayList
    
    Type Parameters:
    
    E - 集合元素类型
    
    Parameters:
    
    iterable - Iterable
    
    Returns:
    
    Collection 或者 ArrayList
    
    Since:
    
    3.0.9
  - toListMap
```
public static <K,V> Map<K,List<V>> toListMap(Iterable<? extends Map<K,V>> mapList)
```
    行转列，合并相同的键，值合并为列表
    将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:
    
    MapUtil.toListMap(Iterable)
  - toMapList
```
public static <K,V> List<Map<K,V>> toMapList(Map<K,? extends Iterable<V>> listMap)
```
    列转行。将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:
    
    MapUtil.toMapList(Map)
  - toMap
```
public static <K,V> Map<K,V> toMap(Iterable<V> values,
                                   Map<K,V> map,
                                   Func1<V,K> keyFunc)
```
    集合转换为Map，转换规则为：
    按照keyFunc函数规则根据元素对象生成Key，元素作为值
    
    Type Parameters:
    
    K - Map键类型
    
    V - Map值类型
    
    Parameters:
    
    values - 数据列表
    
    map - Map对象，转换后的键值对加入此Map，通过传入此对象自定义Map类型
    
    keyFunc - 生成key的函数
    
    Returns:
    
    生成的map
    
    Since:
    
    5.2.6
  - toMap
```
public static <K,V,E> Map<K,V> toMap(Iterable<E> values,
                                     Map<K,V> map,
                                     Func1<E,K> keyFunc,
                                     Func1<E,V> valueFunc)
```
    集合转换为Map，转换规则为：
    按照keyFunc函数规则根据元素对象生成Key，按照valueFunc函数规则根据元素对象生成value组成新的Map
    
    Type Parameters:
    
    K - Map键类型
    
    V - Map值类型
    
    E - 元素类型
    
    Parameters:
    
    values - 数据列表
    
    map - Map对象，转换后的键值对加入此Map，通过传入此对象自定义Map类型
    
    keyFunc - 生成key的函数
    
    valueFunc - 生成值的策略函数
    
    Returns:
    
    生成的map
    
    Since:
    
    5.2.6
  - addAll
```
public static <T> Collection<T> addAll(Collection<T> collection,
                                       Object value)
```
    将指定对象全部加入到集合中
    提供的对象如果为集合类型，会自动转换为目标元素类型
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    collection - 被加入的集合
    
    value - 对象，可能为Iterator、Iterable、Enumeration、Array
    
    Returns:
    
    被加入集合
  - addAll
```
public static <T> Collection<T> addAll(Collection<T> collection,
                                       Object value,
                                       Type elementType)
```
    将指定对象全部加入到集合中
    提供的对象如果为集合类型，会自动转换为目标元素类型
    如果为String，支持类似于[1,2,3,4] 或者 1,2,3,4 这种格式
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    collection - 被加入的集合
    
    value - 对象，可能为Iterator、Iterable、Enumeration、Array，或者与集合元素类型一致
    
    elementType - 元素类型，为空时，使用Object类型来接纳所有类型
    
    Returns:
    
    被加入集合
  - addAll
```
public static <T> Collection<T> addAll(Collection<T> collection,
                                       Iterator<T> iterator)
```
    加入全部
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 被加入的集合 Collection
    
    iterator - 要加入的Iterator
    
    Returns:
    
    原集合
  - addAll
```
public static <T> Collection<T> addAll(Collection<T> collection,
                                       Iterable<T> iterable)
```
    加入全部
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 被加入的集合 Collection
    
    iterable - 要加入的内容Iterable
    
    Returns:
    
    原集合
  - addAll
```
public static <T> Collection<T> addAll(Collection<T> collection,
                                       Enumeration<T> enumeration)
```
    加入全部
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 被加入的集合 Collection
    
    enumeration - 要加入的内容Enumeration
    
    Returns:
    
    原集合
  - addAll
```
public static <T> Collection<T> addAll(Collection<T> collection,
                                       T[] values)
```
    加入全部
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 被加入的集合 Collection
    
    values - 要加入的内容数组
    
    Returns:
    
    原集合
    
    Since:
    
    3.0.8
  - addAllIfNotContains
```
public static <T> List<T> addAllIfNotContains(List<T> list,
                                              List<T> otherList)
```
    将另一个列表中的元素加入到列表中，如果列表中已经存在此元素则忽略之
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    list - 列表
    
    otherList - 其它列表
    
    Returns:
    
    此列表
  - get
```
public static <T> T get(Collection<T> collection,
                        int index)
```
    获取集合中指定下标的元素值，下标可以为负数，例如-1表示最后一个元素
    如果元素越界，返回null
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    collection - 集合
    
    index - 下标，支持负数
    
    Returns:
    
    元素值
    
    Since:
    
    4.0.6
  - getAny
```
public static <T> List<T> getAny(Collection<T> collection,
                                 int... indexes)
```
    获取集合中指定多个下标的元素值，下标可以为负数，例如-1表示最后一个元素
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    collection - 集合
    
    indexes - 下标，支持负数
    
    Returns:
    
    元素值列表
    
    Since:
    
    4.0.6
  - getFirst
```
public static <T> T getFirst(Iterable<T> iterable)
```
    获取集合的第一个元素
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterable - Iterable
    
    Returns:
    
    第一个元素
    
    Since:
    
    3.0.1
    
    See Also:
    
    IterUtil.getFirst(Iterable)
  - getFirst
```
public static <T> T getFirst(Iterator<T> iterator)
```
    获取集合的第一个元素
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterator - Iterator
    
    Returns:
    
    第一个元素
    
    Since:
    
    3.0.1
    
    See Also:
    
    IterUtil.getFirst(Iterator)
  - getLast
```
public static <T> T getLast(Collection<T> collection)
```
    获取集合的最后一个元素
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - Collection
    
    Returns:
    
    最后一个元素
    
    Since:
    
    4.1.10
  - getElementType
```
public static Class<?> getElementType(Iterable<?> iterable)
```
    获得Iterable对象的元素类型（通过第一个非空元素判断）
    
    Parameters:
    
    iterable - Iterable
    
    Returns:
    
    元素类型，当列表为空或元素全部为null时，返回null
    
    Since:
    
    3.0.8
    
    See Also:
    
    IterUtil.getElementType(Iterable)
  - getElementType
```
public static Class<?> getElementType(Iterator<?> iterator)
```
    获得Iterator对象的元素类型（通过第一个非空元素判断）
    
    Parameters:
    
    iterator - Iterator
    
    Returns:
    
    元素类型，当列表为空或元素全部为null时，返回null
    
    Since:
    
    3.0.8
    
    See Also:
    
    IterUtil.getElementType(Iterator)
  - valuesOfKeys
```
public static <K,V> ArrayList<V> valuesOfKeys(Map<K,V> map,
                                              K... keys)
```
    从Map中获取指定键列表对应的值列表
    如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
    
    Type Parameters:
    
    K - 键类型
    
    V - 值类型
    
    Parameters:
    
    map - Map
    
    keys - 键列表
    
    Returns:
    
    值列表
    
    Since:
    
    3.0.8
  - valuesOfKeys
```
public static <K,V> ArrayList<V> valuesOfKeys(Map<K,V> map,
                                              Iterable<K> keys)
```
    从Map中获取指定键列表对应的值列表
    如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
    
    Type Parameters:
    
    K - 键类型
    
    V - 值类型
    
    Parameters:
    
    map - Map
    
    keys - 键列表
    
    Returns:
    
    值列表
    
    Since:
    
    3.0.9
  - valuesOfKeys
```
public static <K,V> ArrayList<V> valuesOfKeys(Map<K,V> map,
                                              Iterator<K> keys)
```
    从Map中获取指定键列表对应的值列表
    如果key在map中不存在或key对应值为null，则返回值列表对应位置的值也为null
    
    Type Parameters:
    
    K - 键类型
    
    V - 值类型
    
    Parameters:
    
    map - Map
    
    keys - 键列表
    
    Returns:
    
    值列表
    
    Since:
    
    3.0.9
  - sortPageAll
```
@SafeVarargs
public static <T> List<T> sortPageAll(int pageNo,
                                                   int pageSize,
                                                   Comparator<T> comparator,
                                                   Collection<T>... colls)
```
    将多个集合排序并显示不同的段落（分页）
    采用BoundedPriorityQueue实现分页取局部
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    pageNo - 页码，从0开始计数，0表示第一页
    
    pageSize - 每页的条目数
    
    comparator - 比较器
    
    colls - 集合数组
    
    Returns:
    
    分页后的段落内容
  - page
```
public static <T> List<T> page(int pageNo,
                               int pageSize,
                               List<T> list)
```
    对指定List分页取值
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    pageNo - 页码，从0开始计数，0表示第一页
    
    pageSize - 每页的条目数
    
    list - 列表
    
    Returns:
    
    分页后的段落内容
    
    Since:
    
    4.1.20
  - sort
```
public static <T> List<T> sort(Collection<T> collection,
                               Comparator<? super T> comparator)
```
    排序集合，排序不会修改原集合
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 集合
    
    comparator - 比较器
    
    Returns:
    
    treeSet
  - sort
```
public static <T> List<T> sort(List<T> list,
                               Comparator<? super T> c)
```
    针对List排序，排序会修改原List
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    list - 被排序的List
    
    c - Comparator
    
    Returns:
    
    原list
    
    See Also:
    
    Collections.sort(List, Comparator)
  - sortByProperty
```
public static <T> List<T> sortByProperty(Collection<T> collection,
                                         String property)
```
    根据Bean的属性排序
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    collection - 集合，会被转换为List
    
    property - 属性名
    
    Returns:
    
    排序后的List
    
    Since:
    
    4.0.6
  - sortByProperty
```
public static <T> List<T> sortByProperty(List<T> list,
                                         String property)
```
    根据Bean的属性排序
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    list - List
    
    property - 属性名
    
    Returns:
    
    排序后的List
    
    Since:
    
    4.0.6
  - sortByPinyin
```
public static List<String> sortByPinyin(Collection<String> collection)
```
    根据汉字的拼音顺序排序
    
    Parameters:
    
    collection - 集合，会被转换为List
    
    Returns:
    
    排序后的List
    
    Since:
    
    4.0.8
  - sortByPinyin
```
public static List<String> sortByPinyin(List<String> list)
```
    根据汉字的拼音顺序排序
    
    Parameters:
    
    list - List
    
    Returns:
    
    排序后的List
    
    Since:
    
    4.0.8
  - sort
```
public static <K,V> TreeMap<K,V> sort(Map<K,V> map,
                                      Comparator<? super K> comparator)
```
    排序Map
    
    Type Parameters:
    
    K - 键类型
    
    V - 值类型
    
    Parameters:
    
    map - Map
    
    comparator - Entry比较器
    
    Returns:
    
    TreeMap
    
    Since:
    
    3.0.9
  - 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
    
    Since:
    
    3.0.9
  - 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 - 被排序的Map
    
    comparator - Comparator
    
    Returns:
    
    LinkedList
    
    Since:
    
    3.0.9
  - sortEntryToList
```
public static <K,V> List<Map.Entry<K,V>> sortEntryToList(Collection<Map.Entry<K,V>> collection)
```
    将Set排序（根据Entry的值）
    
    Type Parameters:
    
    K - 键类型
    
    V - 值类型
    
    Parameters:
    
    collection - 被排序的Collection
    
    Returns:
    
    排序后的Set
  - forEach
```
public static <T> void forEach(Iterable<T> iterable,
                               CollUtil.Consumer<T> consumer)
```
    循环遍历 Iterable，使用CollUtil.Consumer 接受遍历的每条数据，并针对每条数据做处理
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterable - Iterable
    
    consumer - CollUtil.Consumer 遍历的每条数据处理器
    
    Since:
    
    5.4.7
  - forEach
```
public static <T> void forEach(Iterator<T> iterator,
                               CollUtil.Consumer<T> consumer)
```
    循环遍历 Iterator，使用CollUtil.Consumer 接受遍历的每条数据，并针对每条数据做处理
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    iterator - Iterator
    
    consumer - CollUtil.Consumer 遍历的每条数据处理器
  - forEach
```
public static <T> void forEach(Enumeration<T> enumeration,
                               CollUtil.Consumer<T> consumer)
```
    循环遍历 Enumeration，使用CollUtil.Consumer 接受遍历的每条数据，并针对每条数据做处理
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    enumeration - Enumeration
    
    consumer - CollUtil.Consumer 遍历的每条数据处理器
  - forEach
```
public static <K,V> void forEach(Map<K,V> map,
                                 CollUtil.KVConsumer<K,V> kvConsumer)
```
    循环遍历Map，使用CollUtil.KVConsumer 接受遍历的每条数据，并针对每条数据做处理
    和JDK8中的map.forEach不同的是，此方法支持index
    
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Parameters:
    
    map - Map
    
    kvConsumer - CollUtil.KVConsumer 遍历的每条数据处理器
  - group
```
public static <T> List<List<T>> group(Collection<T> collection,
                                      Hash32<T> hash)
```
    分组，按照Hash32接口定义的hash算法，集合中的元素放入hash值对应的子列表中
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    collection - 被分组的集合
    
    hash - Hash值算法，决定元素放在第几个分组的规则
    
    Returns:
    
    分组后的集合
  - groupByField
```
public static <T> List<List<T>> groupByField(Collection<T> collection,
                                             String fieldName)
```
    根据元素的指定字段名分组，非Bean都放在第一个分组中
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    collection - 集合
    
    fieldName - 元素Bean中的字段名，非Bean都放在第一个分组中
    
    Returns:
    
    分组列表
  - reverse
```
public static <T> List<T> reverse(List<T> list)
```
    反序给定List，会在原List基础上直接修改
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    list - 被反转的List
    
    Returns:
    
    反转后的List
    
    Since:
    
    4.0.6
  - reverseNew
```
public static <T> List<T> reverseNew(List<T> list)
```
    反序给定List，会创建一个新的List，原List数据不变
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    list - 被反转的List
    
    Returns:
    
    反转后的List
    
    Since:
    
    4.0.6
  - setOrAppend
```
public static <T> List<T> setOrAppend(List<T> list,
                                      int index,
                                      T element)
```
    设置或增加元素。当index小于List的长度时，替换指定位置的值，否则在尾部追加
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    list - List列表
    
    index - 位置
    
    element - 新元素
    
    Returns:
    
    原List
    
    Since:
    
    4.1.2
  - keySet
```
public static <K> Set<K> keySet(Collection<Map<K,?>> mapCollection)
```
    获取指定Map列表中所有的Key
    
    Type Parameters:
    
    K - 键类型
    
    Parameters:
    
    mapCollection - Map列表
    
    Returns:
    
    key集合
    
    Since:
    
    4.5.12
  - values
```
public static <V> List<V> values(Collection<Map<?,V>> mapCollection)
```
    获取指定Map列表中所有的Value
    
    Type Parameters:
    
    V - 值类型
    
    Parameters:
    
    mapCollection - Map列表
    
    Returns:
    
    Value集合
    
    Since:
    
    4.5.12
  - max
```
public static <T extends Comparable<? super T>> T max(Collection<T> coll)
```
    取最大值
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    coll - 集合
    
    Returns:
    
    最大值
    
    Since:
    
    4.6.5
    
    See Also:
    
    Collections.max(Collection)
  - min
```
public static <T extends Comparable<? super T>> T min(Collection<T> coll)
```
    取最小值
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    coll - 集合
    
    Returns:
    
    最小值
    
    Since:
    
    4.6.5
    
    See Also:
    
    Collections.min(Collection)
  - unmodifiable
```
public static <T> Collection<T> unmodifiable(Collection<? extends T> c)
```
    转为只读集合
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    c - 集合
    
    Returns:
    
    只读集合
    
    Since:
    
    5.2.6
  - empty
```
public static <E,T extends Collection<E>> T empty(Class<?> collectionClass)
```
    根据给定的集合类型，返回对应的空集合，支持类型包括： *
```
     1. NavigableSet
     2. SortedSet
     3. Set
     4. List
 
```
    Type Parameters:
    
    E - 元素类型
    
    T - 集合类型
    
    Parameters:
    
    collectionClass - 集合类型
    
    Returns:
    
    空集合
    
    Since:
    
    5.3.1
  - clear
```
public static void clear(Collection<?>... collections)
```
    清除一个或多个集合内的元素，每个集合调用clear()方法
    
    Parameters:
    
    collections - 一个或多个集合
    
    Since:
    
    5.3.6
  - padLeft
```
public static <T> void padLeft(List<T> list,
                               int minLen,
                               T padObj)
```
    填充List，以达到最小长度
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    list - 列表
    
    minLen - 最小长度
    
    padObj - 填充的对象
    
    Since:
    
    5.3.10
  - padRight
```
public static <T> void padRight(Collection<T> list,
                                int minLen,
                                T padObj)
```
    填充List，以达到最小长度
    
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    list - 列表
    
    minLen - 最小长度
    
    padObj - 填充的对象
    
    Since:
    
    5.3.10
  - 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:
    
    新类型的集合
    
    Since:
    
    5.4.3
  - size
```
public static int size(Object object)
```
    获取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
    
    Since:
    
    5.5.0

Class CollUtil

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CollUtil

Method Detail

emptyIfNull

emptyIfNull

union

union

unionDistinct

unionAll

intersection

intersection

intersectionDistinct

disjunction

subtract

subtractToList

contains

contains

containsAny

containsAll

countMap

join

join

join

popPart

popPart

newHashMap

newHashMap

newHashMap

newHashSet

newLinkedHashSet

set

newHashSet

newHashSet

newHashSet

newHashSet

list

list

list

list

list

list

newArrayList

toList

newArrayList

newArrayList

newArrayList

newArrayList

newLinkedList

newCopyOnWriteArrayList

newBlockingQueue

create

createMap

distinct

sub

sub

sub

sub

splitList

split

filter

filter

filterNew

filterNew

removeAny

filter

removeNull

removeEmpty

removeBlank

extract

extract

map

getFieldValues

getFieldValues

getFieldValues

fieldValueMap