com.xiaoleilu.hutool.util

类 CollectionUtil

java.lang.Object

com.xiaoleilu.hutool.util.CollectionUtil

public class CollectionUtil
extends Object

集合相关工具类，包括数组

作者:

xiaoleilu

嵌套类概要

嵌套类

限定符和类型	类和说明
static interface	CollectionUtil.Consumer<T> 针对一个参数做相应的操作
static interface	CollectionUtil.KVConsumer<K,V> 针对两个参数做相应的操作，例如Map中的KEY和VALUE

方法概要

方法

限定符和类型	方法和说明
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 <E> Enumeration<E>	asEnumeration(Iterator<E> iter) Iterator转换为Enumeration Adapt the specified Iterator to the Enumeration interface.
static <E> Iterator<E>	asIterator(Enumeration<E> e) Enumeration转换为Iterator Adapt the specified Enumeration to the Iterator interface
static boolean	containsAny(Collection<?> coll1, Collection<?> coll2) 其中一个集合在另一个集合中是否至少包含一个元素，既是两个集合是否至少有一个共同的元素
static <T> int	count(Iterable<T> iterable, Matcher<T> matcher) 集合中匹配规则的数量
static <T> Map<T,Integer>	countMap(Collection<T> collection) 根据集合返回一个元素计数的 Map 所谓元素计数就是假如这个集合中某个元素出现了n次，那将这个元素做为key，n做为value 例如：[a,b,c,c,c] 得到： a: 1 b: 1 c: 3
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> ArrayList<T>	distinct(Collection<T> collection) 去重集合
static <T> Collection<T>	filter(Collection<T> collection, Editor<T> editor) 过滤 过滤会改变原集合的内容
static <K,V> Map<K,V>	filter(Map<K,V> map, Editor<Map.Entry<K,V>> editor) 过滤
static <T> void	forEach(Enumeration<T> enumeration, CollectionUtil.Consumer<T> consumer) 循环遍历 Enumeration，使用CollectionUtil.Consumer 接受遍历的每条数据，并针对每条数据做处理
static <T> void	forEach(Iterator<T> iterator, CollectionUtil.Consumer<T> consumer) 循环遍历 Iterator，使用CollectionUtil.Consumer 接受遍历的每条数据，并针对每条数据做处理
static <K,V> void	forEach(Map<K,V> map, CollectionUtil.KVConsumer<K,V> kvConsumer) 循环遍历Map，使用CollectionUtil.KVConsumer 接受遍历的每条数据，并针对每条数据做处理
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 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 <T> boolean	isNotEmpty(Map<?,?> map) Map是否为非空
static <T> String	join(Iterable<T> iterable, String conjunction) 以 conjunction 为分隔符将集合转换为字符串
static <T> String	join(Iterator<T> iterator, String conjunction) 以 conjunction 为分隔符将集合转换为字符串
static <T> ArrayList<T>	newArrayList(Collection<T> collection) 新建一个ArrayList
static <T> ArrayList<T>	newArrayList(T... values) 新建一个ArrayList
static <T,K> HashMap<T,K>	newHashMap() 新建一个HashMap
static <T,K> HashMap<T,K>	newHashMap(boolean isSorted) 新建一个HashMap
static <T,K> HashMap<T,K>	newHashMap(int size) 新建一个HashMap
static <T> HashSet<T>	newHashSet(boolean isSorted, Collection<T> collection) 新建一个HashSet
static <T> HashSet<T>	newHashSet(boolean isSorted, T... ts) 新建一个HashSet
static <T> HashSet<T>	newHashSet(Collection<T> collection) 新建一个HashSet
static <T> HashSet<T>	newHashSet(T... ts) 新建一个HashSet
static <T> List<T>	popPart(Deque<T> surplusAlaDatas, int partSize) 切取部分数据
static <T> List<T>	popPart(Stack<T> surplusAlaDatas, int partSize) 切取部分数据
static <T> List<T>	sort(Collection<T> collection, Comparator<T> comparator) 排序集合
static List<Map.Entry<Long,Long>>	sortEntrySetToList(Set<Map.Entry<Long,Long>> set) 将Set排序（根据Entry的值）
static <T> List<T>	sortPageAll(int pageNo, int numPerPage, Comparator<T> comparator, Collection<T>... colls) 将多个集合排序并显示不同的段落（分页）
static <T> List<T>	sortPageAll2(int pageNo, int numPerPage, Comparator<T> comparator, Collection<T>... colls) 将多个集合排序并显示不同的段落（分页）
static <T> List<List<T>>	split(Collection<T> collection, int size) 对集合按照指定长度分段，每一个段为单独的集合，返回这个集合的列表
static <T> List<T>	sub(Collection<T> list, int start, int end) 截取集合的部分
static <T> List<T>	sub(List<T> list, int start, int end) 截取数组的部分
static <T,K> HashMap<T,K>	toMap(Collection<Map.Entry<T,K>> entryCollection) 将Entry集合转换为HashMap
static <T> TreeSet<T>	toTreeSet(Collection<T> collection, Comparator<T> comparator) 将集合转换为排序后的TreeSet
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,K> Map<T,K>	zip(Collection<T> keys, Collection<K> 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()函数） 例如： keys = a,b,c,d values = 1,2,3,4 delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分

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

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

方法详细资料

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

参数:

coll1 - 集合1

coll2 - 集合2

返回:

并集的集合，返回 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

参数:

coll1 - 集合1

coll2 - 集合2

otherColls - 其它集合

返回:

并集的集合，返回 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

参数:

coll1 - 集合1

coll2 - 集合2

返回:

交集的集合，返回 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

参数:

coll1 - 集合1

coll2 - 集合2

otherColls - 其它集合

返回:

并集的集合，返回 ArrayList

disjunction

public static <T> Collection<T> disjunction(Collection<T> coll1,
                            Collection<T> coll2)

两个集合的差集
针对一个集合中存在多个相同元素的情况，计算两个集合中此元素的个数，保留两个集合中此元素个数差的个数
例如：集合1：[a, b, c, c, c]，集合2：[a, b, c, c]
结果：[c]，此结果中只保留了一个

参数:

coll1 - 集合1

coll2 - 集合2

返回:

差集的集合，返回 ArrayList

containsAny

public static boolean containsAny(Collection<?> coll1,
                  Collection<?> coll2)

其中一个集合在另一个集合中是否至少包含一个元素，既是两个集合是否至少有一个共同的元素

参数:

coll1 - 集合1

coll2 - 集合2

返回:

其中一个集合在另一个集合中是否至少包含一个元素

从以下版本开始:

2.1

另请参阅:

intersection(java.util.Collection<T>, java.util.Collection<T>)

countMap

public static <T> Map<T,Integer> countMap(Collection<T> collection)

根据集合返回一个元素计数的 Map
所谓元素计数就是假如这个集合中某个元素出现了n次，那将这个元素做为key，n做为value
例如：[a,b,c,c,c] 得到：
a: 1
b: 1
c: 3

参数:

collection - 集合

返回:

Map

join

public static <T> String join(Iterable<T> iterable,
              String conjunction)

以 conjunction 为分隔符将集合转换为字符串

类型参数:

T - 被处理的集合

参数:

iterable - Iterable

conjunction - 分隔符

返回:

连接后的字符串

join

public static <T> String join(Iterator<T> iterator,
              String conjunction)

以 conjunction 为分隔符将集合转换为字符串

类型参数:

T - 被处理的集合

参数:

iterator - 集合

conjunction - 分隔符

返回:

连接后的字符串

sortPageAll

@SafeVarargs
public static <T> List<T> sortPageAll(int pageNo,
                                  int numPerPage,
                                  Comparator<T> comparator,
                                  Collection<T>... colls)

将多个集合排序并显示不同的段落（分页）

参数:

pageNo - 页码，从1开始

numPerPage - 每页的条目数

comparator - 比较器

colls - 集合数组

返回:

分页后的段落内容

sortPageAll2

@SafeVarargs
public static <T> List<T> sortPageAll2(int pageNo,
                                   int numPerPage,
                                   Comparator<T> comparator,
                                   Collection<T>... colls)

将多个集合排序并显示不同的段落（分页）

参数:

pageNo - 页码

numPerPage - 每页的条目数

comparator - 比较器

colls - 集合数组

返回:

分业后的段落内容

sortEntrySetToList

public static List<Map.Entry<Long,Long>> sortEntrySetToList(Set<Map.Entry<Long,Long>> set)

将Set排序（根据Entry的值）

参数:

set - 被排序的Set

返回:

排序后的Set

popPart

public static <T> List<T> popPart(Stack<T> surplusAlaDatas,
                  int partSize)

切取部分数据

类型参数:

T - 集合元素类型

参数:

surplusAlaDatas - 原数据

partSize - 每部分数据的长度

返回:

切取出的数据或null

popPart

public static <T> List<T> popPart(Deque<T> surplusAlaDatas,
                  int partSize)

切取部分数据

类型参数:

T - 集合元素类型

参数:

surplusAlaDatas - 原数据

partSize - 每部分数据的长度

返回:

切取出的数据或null

newHashMap

public static <T,K> HashMap<T,K> newHashMap()

新建一个HashMap

返回:

HashMap对象

newHashMap

public static <T,K> HashMap<T,K> newHashMap(boolean isSorted)

新建一个HashMap

参数:

isSorted - Map的Key是否有序，有序返回 LinkedHashMap，否则返回 HashMap

返回:

HashMap对象

newHashMap

public static <T,K> HashMap<T,K> newHashMap(int size)

新建一个HashMap

参数:

size - 初始大小，由于默认负载因子0.75，传入的size会实际初始大小为size / 0.75

返回:

HashMap对象

newHashSet

@SafeVarargs
public static <T> HashSet<T> newHashSet(T... ts)

新建一个HashSet

参数:

ts - 元素数组

返回:

HashSet对象

newHashSet

@SafeVarargs
public static <T> HashSet<T> newHashSet(boolean isSorted,
                                    T... ts)

新建一个HashSet

参数:

isSorted - 是否有序，有序返回 LinkedHashSet，否则返回 HashSet

ts - 元素数组

返回:

HashSet对象

newHashSet

public static <T> HashSet<T> newHashSet(Collection<T> collection)

新建一个HashSet

返回:

HashSet对象

newHashSet

public static <T> HashSet<T> newHashSet(boolean isSorted,
                        Collection<T> collection)

新建一个HashSet

返回:

HashSet对象

newArrayList

@SafeVarargs
public static <T> ArrayList<T> newArrayList(T... values)

新建一个ArrayList

参数:

values - 数组

返回:

ArrayList对象

newArrayList

public static <T> ArrayList<T> newArrayList(Collection<T> collection)

新建一个ArrayList

参数:

collection - 集合

返回:

ArrayList对象

distinct

public static <T> ArrayList<T> distinct(Collection<T> collection)

去重集合

参数:

collection - 集合

返回:

ArrayList

sub

public static <T> List<T> sub(List<T> list,
              int start,
              int end)

截取数组的部分

参数:

list - 被截取的数组

start - 开始位置（包含）

end - 结束位置（不包含）

返回:

截取后的数组，当开始位置超过最大时，返回null

sub

public static <T> List<T> sub(Collection<T> list,
              int start,
              int end)

截取集合的部分

参数:

list - 被截取的数组

start - 开始位置（包含）

end - 结束位置（不包含）

返回:

截取后的数组，当开始位置超过最大时，返回null

split

public static <T> List<List<T>> split(Collection<T> collection,
                      int size)

对集合按照指定长度分段，每一个段为单独的集合，返回这个集合的列表

参数:

collection - 集合

size - 每个段的长度

返回:

分段列表

filter

public static <T> Collection<T> filter(Collection<T> collection,
                       Editor<T> editor)

过滤
过滤会改变原集合的内容

参数:

collection - 集合

editor - 编辑器接口

返回:

过滤后的数组

filter

public static <K,V> Map<K,V> filter(Map<K,V> map,
                    Editor<Map.Entry<K,V>> editor)

过滤

参数:

map - Map

editor - 编辑器接口

返回:

过滤后的Map

count

public static <T> int count(Iterable<T> iterable,
            Matcher<T> matcher)

集合中匹配规则的数量

参数:

iterable - Iterable

matcher - 匹配器，为空则全部匹配

返回:

匹配数量

isEmpty

public static boolean isEmpty(Collection<?> collection)

集合是否为空

参数:

collection - 集合

返回:

是否为空

isEmpty

public static boolean isEmpty(Map<?,?> map)

Map是否为空

参数:

map - 集合

返回:

是否为空

isEmpty

public static boolean isEmpty(Iterable<?> iterable)

Iterable是否为空

参数:

iterable - Iterable对象

返回:

是否为空

isEmpty

public static boolean isEmpty(Iterator<?> Iterator)

Iterator是否为空

参数:

Iterator - Iterator对象

返回:

是否为空

isEmpty

public static boolean isEmpty(Enumeration<?> enumeration)

Enumeration是否为空

参数:

enumeration - Enumeration

返回:

是否为空

isNotEmpty

public static boolean isNotEmpty(Collection<?> collection)

集合是否为非空

参数:

collection - 集合

返回:

是否为非空

isNotEmpty

public static <T> boolean isNotEmpty(Map<?,?> map)

Map是否为非空

参数:

map - 集合

返回:

是否为非空

isNotEmpty

public static boolean isNotEmpty(Iterable<?> iterable)

Iterable是否为空

参数:

iterable - Iterable对象

返回:

是否为空

isNotEmpty

public static boolean isNotEmpty(Iterator<?> Iterator)

Iterator是否为空

参数:

Iterator - Iterator对象

返回:

是否为空

isNotEmpty

public static boolean isNotEmpty(Enumeration<?> enumeration)

Enumeration是否为空

参数:

enumeration - Enumeration

返回:

是否为空

zip

public static Map<String,String> zip(String keys,
                     String values,
                     String delimiter)

映射键值（参考Python的zip()函数）
例如：
keys = a,b,c,d
values = 1,2,3,4
delimiter = , 则得到的Map是 {a=1, b=2, c=3, d=4}
如果两个数组长度不同，则只对应最短部分

参数:

keys - 键列表

values - 值列表

返回:

Map

zip

public static <T,K> Map<T,K> zip(Collection<T> keys,
                 Collection<K> values)

映射键值（参考Python的zip()函数）
例如：
keys = [a,b,c,d]
values = [1,2,3,4]
则得到的Map是 {a=1, b=2, c=3, d=4}
如果两个数组长度不同，则只对应最短部分

参数:

keys - 键列表

values - 值列表

返回:

Map

toMap

public static <T,K> HashMap<T,K> toMap(Collection<Map.Entry<T,K>> entryCollection)

将Entry集合转换为HashMap

参数:

entryCollection - entry集合

返回:

Map

toTreeSet

public static <T> TreeSet<T> toTreeSet(Collection<T> collection,
                       Comparator<T> comparator)

将集合转换为排序后的TreeSet

参数:

collection - 集合

comparator - 比较器

返回:

treeSet

sort

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

排序集合

参数:

collection - 集合

comparator - 比较器

返回:

treeSet

asEnumeration

public static <E> Enumeration<E> asEnumeration(Iterator<E> iter)

Iterator转换为Enumeration Adapt the specified Iterator to the Enumeration interface.

参数:

iter - Iterator

返回:

Enumeration

asIterator

public static <E> Iterator<E> asIterator(Enumeration<E> e)

Enumeration转换为Iterator
Adapt the specified Enumeration to the Iterator interface

参数:

e - Enumeration

返回:

Iterator

addAll

public static <T> Collection<T> addAll(Collection<T> collection,
                       Iterator<T> iterator)

加入全部

参数:

collection - 集合 Collection

iterator - Iterator

返回:

原集合

addAll

public static <T> Collection<T> addAll(Collection<T> collection,
                       Iterable<T> iterable)

加入全部

参数:

collection - 集合 Collection

iterable - Iterable

返回:

原集合

addAll

public static <T> Collection<T> addAll(Collection<T> collection,
                       Enumeration<T> enumeration)

加入全部

参数:

collection - 集合 Collection

enumeration - Enumeration

返回:

原集合

forEach

public static <T> void forEach(Iterator<T> iterator,
               CollectionUtil.Consumer<T> consumer)

循环遍历 Iterator，使用CollectionUtil.Consumer 接受遍历的每条数据，并针对每条数据做处理

参数:

iterator - Iterator

consumer - CollectionUtil.Consumer 遍历的每条数据处理器

forEach

public static <T> void forEach(Enumeration<T> enumeration,
               CollectionUtil.Consumer<T> consumer)

循环遍历 Enumeration，使用CollectionUtil.Consumer 接受遍历的每条数据，并针对每条数据做处理

参数:

enumeration - Enumeration

consumer - CollectionUtil.Consumer 遍历的每条数据处理器

forEach

public static <K,V> void forEach(Map<K,V> map,
                 CollectionUtil.KVConsumer<K,V> kvConsumer)

循环遍历Map，使用CollectionUtil.KVConsumer 接受遍历的每条数据，并针对每条数据做处理

参数:

map - Map

kvConsumer - CollectionUtil.KVConsumer 遍历的每条数据处理器