public class CollUtil extends Object
此工具方法针对Collection
或Iterable
及其实现类封装的工具。
IterUtil
Constructor and Description |
---|
CollUtil() |
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,
Object value,
Type elementType,
Converter converter)
将指定对象全部加入到集合中
提供的对象如果为集合类型,会自动转换为目标元素类型 如果为String,支持类似于[1,2,3,4] 或者 1,2,3,4 这种格式 |
static <T> Collection<T> |
addAll(Collection<T> collection,
T[] values)
加入全部
|
static <T,S extends T> |
addIfAbsent(Collection<T> collection,
S object)
一个对象不为空且不存在于该集合中时,加入到该集合中
null, null -> false [], null -> false null, "123" -> false ["123"], "123" -> false [], "123" -> true ["456"], "123" -> true [Animal{"name": "jack"}], Dog{"name": "jack"} -> true |
static <T> boolean |
allMatch(Collection<T> collection,
Predicate<T> predicate)
是否全部匹配判断条件
|
static <T> boolean |
anyMatch(Collection<T> collection,
Predicate<T> predicate)
是否至少有一个符合判断条件
|
static <E> Enumeration<E> |
asEnumeration(Iterator<E> iter)
Iterator转换为Enumeration
Adapt the specified
Iterator to the Enumeration interface. |
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中所有的元素。
|
static boolean |
containsAny(Collection<?> coll1,
Collection<?> coll2)
其中一个集合在另一个集合中是否至少包含一个元素,即是两个集合是否至少有一个共同的元素
|
static <T> int |
count(Iterable<T> iterable,
Predicate<T> predicate)
集合中匹配规则的数量
|
static <T> Map<T,Integer> |
countMap(Iterable<T> collection)
|
static <T> Collection<T> |
create(Class<?> collectionType)
创建新的集合对象,返回具体的泛型集合
|
static <T> Collection<T> |
create(Class<?> collectionType,
Class<T> elementType)
创建新的集合对象,返回具体的泛型集合
|
static <T extends Collection<E>,E> |
defaultIfEmpty(T collection,
Function<T,T> handler,
Supplier<? extends T> defaultSupplier)
如果给定集合为空,返回默认集合
|
static <T extends Collection<E>,E> |
defaultIfEmpty(T collection,
T defaultCollection)
如果给定集合为空,返回默认集合
|
static <T> Collection<T> |
disjunction(Collection<T> coll1,
Collection<T> coll2)
两个集合的对称差集 (A-B)∪(B-A)
针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留两个集合中此元素个数差的个数 例如: 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] 任意一个集合为空,返回另一个集合 两个集合无差集则返回空集合 |
static <T> ArrayList<T> |
distinct(Collection<T> collection)
去重集合
|
static <T,K> List<T> |
distinct(Collection<T> collection,
Function<T,K> uniqueGenerator,
boolean override)
根据函数生成的KEY去重集合,如根据Bean的某个或者某些字段完成去重。
|
static <T extends Collection<E>,E> |
edit(T collection,
UnaryOperator<E> editor)
编辑,此方法产生一个新集合
编辑过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能: 1、过滤出需要的对象,如果返回null表示这个元素对象抛弃 2、修改元素对象,返回集合中为修改后的对象 |
static <E,T extends Collection<E>> |
empty(Class<?> collectionClass)
根据给定的集合类型,返回对应的空集合,支持类型包括:
1.
|
static <T> List<T> |
emptyIfNull(List<T> list)
|
static <T> Set<T> |
emptyIfNull(Set<T> set)
|
static boolean |
equals(Collection<?> coll1,
Collection<?> coll2,
boolean ignoreOrder)
判断两个
Iterable 中的元素是否相同,可选是否判断顺序
当满足下列情况时返回true :
两个Iterable 都为null ;
两个Iterable 满足coll1 == coll2 ;
如果忽略顺序,则计算两个集合中元素和数量是否相同
如果不忽略顺序,两个Iterable 所有具有相同下标的元素皆满足Objects.equals(Object, Object) ;
|
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 extends Collection<E>,E> |
filter(T collection,
Predicate<E> predicate)
|
static <T> List<T> |
flat(Collection<?> collection)
解构多层集合
例如:
List<List<List<String>>> 解构成 List<String> |
static <T> List<T> |
flat(Collection<?> collection,
boolean skipNull)
解构多层集合
例如:
List<List<List<String>>> 解构成 List<String>
skipNull如果为true, 则解构后的集合里不包含null值,为false则会包含null值。 |
static <T> void |
forEach(Enumeration<T> enumeration,
SerBiConsumer<Integer,T> consumer)
循环遍历
Enumeration ,使用SerBiConsumer 接受遍历的每条数据,并针对每条数据做处理 |
static <T> void |
forEach(Iterable<T> iterable,
SerBiConsumer<Integer,T> consumer)
循环遍历
Iterable ,使用SerBiConsumer 接受遍历的每条数据,并针对每条数据做处理 |
static <T> void |
forEach(Iterator<T> iterator,
SerBiConsumer<Integer,T> consumer)
循环遍历
Iterator ,使用SerBiConsumer 接受遍历的每条数据,并针对每条数据做处理 |
static <K,V> void |
forEach(Map<K,V> map,
SerConsumer3<Integer,K,V> kvConsumer)
循环遍历Map,使用
SerConsumer3 接受遍历的每条数据,并针对每条数据做处理和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 Collection<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)
获取集合的第一个元素,如果集合为空(null或者空集合),返回
null |
static <T> T |
getFirst(Iterable<T> collection,
Predicate<T> predicate)
查找第一个匹配元素对象
|
static <T> T |
getFirstByField(Iterable<T> collection,
String fieldName,
Object fieldValue)
查找第一个匹配元素对象
如果集合元素是Map,则比对键和值是否相同,相同则返回 如果为普通Bean,则通过反射比对元素字段名对应的字段值是否相同,相同则返回 如果给定字段值参数是 null 且元素对象中的字段值也为null 则认为相同 |
static <T> T |
getFirstNoneNull(Iterable<T> iterable)
获取集合的第一个非空元素
|
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 <T> List<List<T>> |
groupByFunc(Collection<T> collection,
Function<T,?> getter)
根据元素的指定字段值分组,非Bean都放在第一个分组中
例如: CollUtil.groupByFunc(list, TestBean::getAge)
|
static boolean |
hasNull(Iterable<?> iterable)
是否包含
null 元素集合为 null ,返回true
集合为空集合,即元素个数为0,返回false
集合中元素为"",返回false
|
static <T> List<Integer> |
indexListOfAll(Collection<T> collection,
Predicate<T> predicate)
获取匹配规则定义中匹配到元素的所有位置
此方法对于某些无序集合的位置信息,以转换为数组后的位置为准。 |
static <T> int |
indexOf(Collection<T> collection,
Predicate<T> predicate)
获取匹配规则定义中匹配到元素的第一个位置
此方法对于某些无序集合的位置信息,以转换为数组后的位置为准。 |
static <T> int[] |
indexOfAll(Collection<T> collection,
Predicate<T> predicate)
获取匹配规则定义中匹配到元素的所有位置
此方法对于某些无序集合的位置信息,以转换为数组后的位置为准。 |
static <T> Collection<T> |
intersection(Collection<T>... colls)
多个集合的交集
针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留最少的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c],此结果中只保留了两个c |
static <T> Set<T> |
intersectionDistinct(Collection<T>... colls)
多个集合的交集
针对一个集合中存在多个相同元素的情况,只保留一个 例如:集合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 |
isEqualList(Collection<?> list1,
Collection<?> list2)
判断两个
Collection 是否元素和顺序相同,返回true 的条件是:
两个Collection 必须长度相同
两个Collection 元素相同index的对象必须equals,满足Objects.equals(Object, Object)
此方法来自Apache-Commons-Collections4。 |
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 boolean |
isSub(Collection<?> subCollection,
Collection<?> collection)
判断subCollection是否为collection的子集合,不考虑顺序,只考虑元素数量。
|
static <T> String |
join(Iterable<T> iterable,
CharSequence conjunction)
|
static <T> String |
join(Iterable<T> iterable,
CharSequence conjunction,
Function<T,? extends CharSequence> func)
以 conjunction 为分隔符将集合转换为字符串
|
static <T> String |
join(Iterable<T> iterable,
CharSequence conjunction,
String prefix,
String suffix)
以 conjunction 为分隔符将集合转换为字符串
|
static <K> Set<K> |
keySet(Collection<Map<K,?>> mapCollection)
获取指定Map列表中所有的Key
|
static <T> int |
lastIndexOf(Collection<T> collection,
Predicate<? super T> predicate)
获取匹配规则定义中匹配到元素的最后位置
此方法对于某些无序集合的位置信息,以转换为数组后的位置为准。 |
static <T,R> List<R> |
map(Iterable<T> collection,
Function<? super T,? extends R> func)
通过func自定义一个规则,此规则将原集合中的元素转换成新的元素,生成新的列表返回
例如提供的是一个Bean列表,通过Function接口实现获取某个字段值,返回这个字段值组成的新列表 默认忽略映射后 null 的情况 |
static <T,R> List<R> |
map(Iterable<T> collection,
Function<? super T,? extends R> mapper,
boolean ignoreNull)
通过func自定义一个规则,此规则将原集合中的元素转换成新的元素,生成新的列表返回
例如提供的是一个Bean列表,通过Function接口实现获取某个字段值,返回这个字段值组成的新列表 |
static <T extends Comparable<? super T>> |
max(Collection<T> coll)
取最大值
|
static <T extends Comparable<? super T>> |
min(Collection<T> coll)
取最小值
|
static <T> BlockingQueue<T> |
newBlockingQueue(int capacity,
boolean isLinked)
新建
BlockingQueue 在队列为空时,获取元素的线程会等待队列变为非空。 |
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<List<T>> |
partition(Collection<T> collection,
int size)
对集合按照指定长度分段,每一个段为单独的集合,返回这个集合的列表
|
static <T> List<T> |
popPart(Deque<T> surplusAlaDatas,
int partSize)
切取部分数据
切取后的栈将减少这些元素 |
static <T> List<T> |
popPart(Stack<T> surplusAlaDatas,
int partSize)
切取部分数据
切取后的栈将减少这些元素 |
static <T extends Iterable<E>,E> |
remove(T iter,
Predicate<E> predicate)
移除集合中满足条件的所有元素,此方法在原集合上直接修改
通过实现 Predicate 接口,完成元素的移除,可以实现以下功能:
1、移除指定对象,Predicate.test(Object) 方法返回 true 的对象将被使用Iterator.remove() 方法移除。 |
static <T extends Collection<E>,E> |
removeAny(T collection,
E... elesRemoved)
去掉集合中的多个元素,此方法直接修改原集合
|
static <T extends Collection<E>,E extends CharSequence> |
removeBlank(T collection)
去除
null 或者""或者空白字符串 元素,此方法直接修改原集合 |
static <T extends Collection<E>,E extends CharSequence> |
removeEmpty(T collection)
去除
null 或者"" 元素,此方法直接修改原集合 |
static <T extends Collection<E>,E> |
removeNull(T collection)
去除
null 元素,此方法直接修改原集合 |
static <T extends Collection<E>,E> |
removeWithAddIf(T targetCollection,
Predicate<? super E> predicate)
移除集合中的多个元素,并将结果存放到生成的新集合中后返回
此方法直接修改原集合 |
static <T extends Collection<E>,E> |
removeWithAddIf(T targetCollection,
T resultCollection,
Predicate<? super E> predicate)
移除集合中的多个元素,并将结果存放到指定的集合
此方法直接修改原集合
|
static boolean |
safeContains(Collection<?> collection,
Object value)
判断指定集合是否包含指定值,如果集合为空(null或者空),返回
false ,否则找到元素返回true |
static <E,K,V> void |
setValueByMap(Iterable<E> iterable,
Map<K,V> map,
Function<E,K> keyGenerate,
BiConsumer<E,V> biConsumer)
使用给定的map将集合中的元素进行属性或者值的重新设定
|
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<T> |
sub(Collection<T> collection,
int start,
int end)
截取集合的部分
|
static <T> List<T> |
sub(Collection<T> collection,
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】中没有的元素,例如:
subtract([1,2,3,4],[2,3,4,5]) -》 [1]
|
static <T> List<T> |
subtractToList(Collection<T> coll1,
Collection<T> coll2)
计算集合的单差集,即只返回【集合1】中有,但是【集合2】中没有的元素,例如:
subtractToList([1,2,3,4],[2,3,4,5]) -》 [1]
|
static <E> Collection<E> |
toCollection(Iterable<E> iterable)
|
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] } |
static <K,V> List<Map<K,V>> |
toMapList(Map<K,? extends Iterable<V>> listMap)
列转行。
|
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<? extends T>... colls)
多个集合的并集
针对一个集合中存在多个相同元素的情况,计算两个集合中此元素的个数,保留最多的个数 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c, c, c],此结果中只保留了三个c |
static <T> List<T> |
unionAll(Collection<? extends T>... colls)
多个集合的完全并集,类似于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<? extends T>... colls)
多个集合的非重复并集,类似于SQL中的“UNION DISTINCT”
针对一个集合中存在多个相同元素的情况,只保留一个 例如:集合1:[a, b, c, c, c],集合2:[a, b, c, c] 结果:[a, b, c],此结果中只保留了一个c |
static <V> List<V> |
values(Collection<Map<?,V>> mapCollection)
获取指定Map列表中所有的Value
|
static <T> Collection<T> |
view(Collection<? extends T> c)
转为只读集合
|
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} 如果两个数组长度不同,则只对应最短部分 |
public static boolean isEmpty(Collection<?> collection)
collection
- 集合public static boolean isEmpty(Iterable<?> iterable)
iterable
- Iterable对象IterUtil.isEmpty(Iterable)
public static boolean isEmpty(Iterator<?> iterator)
iterator
- Iterator对象IterUtil.isEmpty(Iterator)
public static boolean isEmpty(Enumeration<?> enumeration)
enumeration
- Enumeration
public static boolean isEmpty(Map<?,?> map)
map
- 集合MapUtil.isEmpty(Map)
public static <T extends Collection<E>,E> T defaultIfEmpty(T collection, T defaultCollection)
T
- 集合类型E
- 集合元素类型collection
- 集合defaultCollection
- 默认数组public static <T extends Collection<E>,E> T defaultIfEmpty(T collection, Function<T,T> handler, Supplier<? extends T> defaultSupplier)
T
- 集合类型E
- 集合元素类型collection
- 集合handler
- 非空的处理函数defaultSupplier
- 默认值懒加载函数public static <T> Set<T> emptyIfNull(Set<T> set)
T
- 集合元素类型set
- 提供的集合,可能为nullpublic static <T> List<T> emptyIfNull(List<T> list)
T
- 集合元素类型list
- 提供的集合,可能为nullpublic static boolean isNotEmpty(Collection<?> collection)
collection
- 集合public static boolean isNotEmpty(Iterable<?> iterable)
iterable
- Iterable对象IterUtil.isNotEmpty(Iterable)
public static boolean isNotEmpty(Iterator<?> iterator)
iterator
- Iterator对象IterUtil.isNotEmpty(Iterator)
public static boolean isNotEmpty(Enumeration<?> enumeration)
enumeration
- Enumeration
public static boolean hasNull(Iterable<?> iterable)
null
元素null
,返回true
false
false
iterable
- 被检查的Iterable对象,如果为null
返回truenull
元素IterUtil.hasNull(Iterator)
public static boolean isNotEmpty(Map<?,?> map)
map
- 集合MapUtil.isNotEmpty(Map)
public static <T> ArrayList<T> distinct(Collection<T> collection)
T
- 集合元素类型collection
- 集合ArrayList
public static <T,K> List<T> distinct(Collection<T> collection, Function<T,K> uniqueGenerator, boolean override)
T
- 集合元素类型K
- 唯一键类型collection
- 集合uniqueGenerator
- 唯一键生成器override
- 是否覆盖模式,如果为true
,加入的新值会覆盖相同key的旧值,否则会忽略新加值ArrayList
@SafeVarargs public static <T> Collection<T> union(Collection<? extends T>... colls)
T
- 集合元素类型colls
- 集合数组ArrayList
@SafeVarargs public static <T> Set<T> unionDistinct(Collection<? extends T>... colls)
T
- 集合元素类型colls
- 列表集合LinkedHashSet
@SafeVarargs public static <T> List<T> unionAll(Collection<? extends T>... colls)
T
- 集合元素类型colls
- 集合数组ArrayList
@SafeVarargs public static <T> Collection<T> intersection(Collection<T>... colls)
T
- 集合元素类型colls
- 集合列表ArrayList
@SafeVarargs public static <T> Set<T> intersectionDistinct(Collection<T>... colls)
T
- 集合元素类型colls
- 集合列表LinkedHashSet
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]任意一个集合为空,返回另一个集合
T
- 集合元素类型coll1
- 集合1coll2
- 集合2ArrayList
public static <T> Collection<T> subtract(Collection<T> coll1, Collection<T> coll2)
subtract([1,2,3,4],[2,3,4,5]) -》 [1]
T
- 元素类型coll1
- 集合1coll2
- 集合2public static <T> List<T> subtractToList(Collection<T> coll1, Collection<T> coll2)
subtractToList([1,2,3,4],[2,3,4,5]) -》 [1]
T
- 元素类型coll1
- 集合1coll2
- 集合2public static boolean contains(Collection<?> collection, Object value)
false
,否则找到元素返回true
collection
- 集合value
- 需要查找的值false
,否则找到元素返回true
ClassCastException
- 如果类型不一致会抛出转换异常NullPointerException
- 当指定的元素 值为 null ,或集合类不支持null 时抛出该异常Collection.contains(Object)
public static boolean safeContains(Collection<?> collection, Object value)
false
,否则找到元素返回true
collection
- 集合value
- 需要查找的值false
,否则找到元素返回true
public static <T> boolean contains(Collection<T> collection, Predicate<? super T> containFunc)
T
- 值类型collection
- 集合containFunc
- 自定义判断函数public static boolean containsAny(Collection<?> coll1, Collection<?> coll2)
coll1
- 集合1coll2
- 集合2intersection(java.util.Collection<T>...)
public static boolean containsAll(Collection<?> coll1, Collection<?> coll2)
true
当集合2为空时,返回true
coll1
- 集合1coll2
- 集合2public static <T> Map<T,Integer> countMap(Iterable<T> collection)
T
- 集合元素类型collection
- 集合Map
IterUtil.countMap(Iterator)
public static <T> String join(Iterable<T> iterable, CharSequence conjunction, Function<T,? extends CharSequence> func)
T
- 集合元素类型iterable
- Iterable
conjunction
- 分隔符func
- 集合元素转换器,将元素转换为字符串IterUtil.join(Iterator, CharSequence, Function)
public static <T> String join(Iterable<T> iterable, CharSequence conjunction)
T
- 集合元素类型iterable
- Iterable
conjunction
- 分隔符IterUtil.join(Iterator, CharSequence)
public static <T> String join(Iterable<T> iterable, CharSequence conjunction, String prefix, String suffix)
T
- 集合元素类型iterable
- Iterable
conjunction
- 分隔符prefix
- 每个元素添加的前缀,null表示不添加suffix
- 每个元素添加的后缀,null表示不添加public static <T> List<T> popPart(Stack<T> surplusAlaDatas, int partSize)
T
- 集合元素类型surplusAlaDatas
- 原数据partSize
- 每部分数据的长度public static <T> List<T> popPart(Deque<T> surplusAlaDatas, int partSize)
T
- 集合元素类型surplusAlaDatas
- 原数据partSize
- 每部分数据的长度public static <T> BlockingQueue<T> newBlockingQueue(int capacity, boolean isLinked)
BlockingQueue
T
- 集合类型capacity
- 容量isLinked
- 是否为链表形式BlockingQueue
public static <E,T extends Collection<E>> T empty(Class<?> collectionClass)
1. NavigableSet 2. SortedSet 3. Set 4. List
E
- 元素类型T
- 集合类型collectionClass
- 集合类型public static <T> Collection<T> create(Class<?> collectionType, Class<T> elementType)
T
- 集合元素类型,rawtype 如 ArrayList.class, EnumSet.class ...collectionType
- 集合类型elementType
- 集合元素类,只用于EnumSet创建,如果创建EnumSet,则此参数必须非空public static <T> Collection<T> create(Class<?> collectionType)
T
- 集合元素类型,rawtype 如 ArrayList.class, EnumSet.class ...collectionType
- 集合类型public static <T> List<T> sub(List<T> list, int start, int end)
T
- 集合元素类型list
- 被截取的数组start
- 开始位置(包含)end
- 结束位置(不包含)ListUtil.sub(List, int, int)
public static <T> List<T> sub(List<T> list, int start, int end, int step)
T
- 集合元素类型list
- 被截取的数组start
- 开始位置(包含)end
- 结束位置(不包含)step
- 步进ListUtil.sub(List, int, int, int)
public static <T> List<T> sub(Collection<T> collection, int start, int end)
T
- 集合元素类型collection
- 被截取的数组start
- 开始位置(包含)end
- 结束位置(不包含)public static <T> List<T> sub(Collection<T> collection, int start, int end, int step)
T
- 集合元素类型collection
- 被截取的数组start
- 开始位置(包含)end
- 结束位置(不包含)step
- 步进public static <T> List<List<T>> partition(Collection<T> collection, int size)
T
- 集合元素类型collection
- 集合size
- 每个段的长度public static <T extends Collection<E>,E> T edit(T collection, UnaryOperator<E> editor)
1、过滤出需要的对象,如果返回null表示这个元素对象抛弃 2、修改元素对象,返回集合中为修改后的对象
T
- 集合类型E
- 集合元素类型collection
- 集合editor
- 编辑器接口,null
返回原集合public static <T extends Collection<E>,E> T filter(T collection, Predicate<E> predicate)
T
- 集合类型E
- 集合元素类型collection
- 集合predicate
- 过滤器,null
返回原集合public static <T extends Collection<E>,E> T removeAny(T collection, E... elesRemoved)
T
- 集合类型E
- 集合元素类型collection
- 集合elesRemoved
- 需要删除的元素public static <T extends Iterable<E>,E> T remove(T iter, Predicate<E> predicate)
Predicate
接口,完成元素的移除,可以实现以下功能:
1、移除指定对象,Predicate.test(Object)
方法返回true
的对象将被使用Iterator.remove()
方法移除。
T
- 集合类型E
- 集合元素类型iter
- 集合predicate
- 过滤器接口public static <T extends Collection<E>,E> T removeNull(T collection)
null
元素,此方法直接修改原集合T
- 集合类型E
- 集合元素类型collection
- 集合public static <T extends Collection<E>,E extends CharSequence> T removeEmpty(T collection)
null
或者"" 元素,此方法直接修改原集合T
- 集合类型E
- 集合元素类型collection
- 集合public static <T extends Collection<E>,E extends CharSequence> T removeBlank(T collection)
null
或者""或者空白字符串 元素,此方法直接修改原集合T
- 集合类型E
- 集合元素类型collection
- 集合public static <T extends Collection<E>,E> T removeWithAddIf(T targetCollection, T resultCollection, Predicate<? super E> predicate)
T
- 集合类型E
- 集合元素类型resultCollection
- 存放移除结果的集合targetCollection
- 被操作移除元素的集合predicate
- 用于是否移除判断的过滤器public static <T extends Collection<E>,E> List<E> removeWithAddIf(T targetCollection, Predicate<? super E> predicate)
T
- 集合类型E
- 集合元素类型targetCollection
- 被操作移除元素的集合predicate
- 用于是否移除判断的过滤器public static <T,R> List<R> map(Iterable<T> collection, Function<? super T,? extends R> func)
null
的情况T
- 集合元素类型R
- 返回集合元素类型collection
- 原集合func
- 编辑函数public static <T,R> List<R> map(Iterable<T> collection, Function<? super T,? extends R> mapper, boolean ignoreNull)
T
- 集合元素类型R
- 返回集合元素类型collection
- 原集合mapper
- 编辑函数ignoreNull
- 是否忽略空值,这里的空值包括函数处理前和处理后的null值Stream.map(Function)
public static Collection<Object> getFieldValues(Iterable<?> collection, String fieldName)
collection
- Bean集合或Map集合fieldName
- 字段名或map的键public static List<Object> getFieldValues(Iterable<?> collection, String fieldName, boolean ignoreNull)
collection
- Bean集合或Map集合fieldName
- 字段名或map的键ignoreNull
- 是否忽略值为null
的字段public static <T> List<T> getFieldValues(Iterable<?> collection, String fieldName, Class<T> elementType)
T
- 元素类型collection
- Bean集合或Map集合fieldName
- 字段名或map的键elementType
- 元素类型类public static <K,V> Map<K,V> fieldValueMap(Iterable<V> iterable, String fieldName)
K
- 字段名对应值得类型,不确定请使用ObjectV
- 对象类型iterable
- 对象列表fieldName
- 字段名(会通过反射获取其值)public static <K,V> Map<K,V> fieldValueAsMap(Iterable<?> iterable, String fieldNameForKey, String fieldNameForValue)
K
- 字段名对应值得类型,不确定请使用ObjectV
- 值类型,不确定使用Objectiterable
- 对象列表fieldNameForKey
- 做为键的字段名(会通过反射获取其值)fieldNameForValue
- 做为值的字段名(会通过反射获取其值)public static <T> int count(Iterable<T> iterable, Predicate<T> predicate)
T
- 集合元素类型iterable
- Iterable
predicate
- 匹配器,为空则全部匹配public static <T> int indexOf(Collection<T> collection, Predicate<T> predicate)
T
- 元素类型collection
- 集合predicate
- 匹配器,为空则全部匹配public static <T> int lastIndexOf(Collection<T> collection, Predicate<? super T> predicate)
T
- 元素类型collection
- 集合predicate
- 匹配器,为空则全部匹配public static <T> int[] indexOfAll(Collection<T> collection, Predicate<T> predicate)
T
- 元素类型collection
- 集合predicate
- 匹配器,为空则全部匹配public static <T> List<Integer> indexListOfAll(Collection<T> collection, Predicate<T> predicate)
T
- 元素类型collection
- 集合predicate
- 匹配器,为空则全部匹配public static Map<String,String> zip(String keys, String values, String delimiter, boolean isOrder)
keys
- 键列表values
- 值列表delimiter
- 分隔符isOrder
- 是否有序public static Map<String,String> zip(String keys, String values, String delimiter)
keys
- 键列表values
- 值列表delimiter
- 分隔符public static <K,V> Map<K,V> zip(Collection<K> keys, Collection<V> values)
K
- 键类型V
- 值类型keys
- 键列表values
- 值列表public static <T> TreeSet<T> toTreeSet(Collection<T> collection, Comparator<T> comparator)
T
- 集合元素类型collection
- 集合comparator
- 比较器public static <E> Enumeration<E> asEnumeration(Iterator<E> iter)
Adapt the specified Iterator
to the Enumeration
interface.
E
- 集合元素类型iter
- Iterator
Enumeration
public static <E> Collection<E> toCollection(Iterable<E> iterable)
E
- 集合元素类型iterable
- Iterable
Collection
或者 ArrayList
public static <K,V> Map<K,List<V>> toListMap(Iterable<? extends Map<K,V>> mapList)
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] }
K
- 键类型V
- 值类型mapList
- Map列表MapUtil.toListMap(Iterable)
public static <K,V> List<Map<K,V>> toMapList(Map<K,? extends Iterable<V>> listMap)
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} ]
K
- 键类型V
- 值类型listMap
- 列表MapMapUtil.toMapList(Map)
public static <T> Collection<T> addAll(Collection<T> collection, Object value)
T
- 元素类型collection
- 被加入的集合value
- 对象,可能为Iterator、Iterable、Enumeration、Arraypublic static <T> Collection<T> addAll(Collection<T> collection, Object value, Type elementType)
T
- 元素类型collection
- 被加入的集合value
- 对象,可能为Iterator、Iterable、Enumeration、Array,或者与集合元素类型一致elementType
- 元素类型,为空时,使用Object类型来接纳所有类型public static <T> Collection<T> addAll(Collection<T> collection, Object value, Type elementType, Converter converter)
T
- 元素类型collection
- 被加入的集合value
- 对象,可能为Iterator、Iterable、Enumeration、Array,或者与集合元素类型一致elementType
- 元素类型,为空时,使用Object类型来接纳所有类型converter
- 自定义元素类型转换器,null
表示使用默认转换器public static <T> Collection<T> addAll(Collection<T> collection, Iterator<T> iterator)
T
- 集合元素类型collection
- 被加入的集合 Collection
iterator
- 要加入的Iterator
public static <T> Collection<T> addAll(Collection<T> collection, Iterable<T> iterable)
T
- 集合元素类型collection
- 被加入的集合 Collection
iterable
- 要加入的内容Iterable
public static <T> Collection<T> addAll(Collection<T> collection, Enumeration<T> enumeration)
T
- 集合元素类型collection
- 被加入的集合 Collection
enumeration
- 要加入的内容Enumeration
public static <T> Collection<T> addAll(Collection<T> collection, T[] values)
T
- 集合元素类型collection
- 被加入的集合 Collection
values
- 要加入的内容数组public static <T> T getFirst(Iterable<T> iterable)
null
T
- 集合元素类型iterable
- Iterable
null
public static <T> T getFirstNoneNull(Iterable<T> iterable)
T
- 集合元素类型iterable
- Iterable
public static <T> T getFirst(Iterable<T> collection, Predicate<T> predicate)
T
- 集合元素类型collection
- 集合predicate
- 过滤器,满足过滤条件的第一个元素将被返回public static <T> T getFirstByField(Iterable<T> collection, String fieldName, Object fieldValue)
null
且元素对象中的字段值也为null
则认为相同T
- 集合元素类型collection
- 集合,集合元素可以是Bean或者MapfieldName
- 集合元素对象的字段名或map的键fieldValue
- 集合元素对象的字段值或map的值public static <T> T getLast(Collection<T> collection)
T
- 集合元素类型collection
- Collection
public static <T> T get(Collection<T> collection, int index)
T
- 元素类型collection
- 集合index
- 下标,支持负数public static <T> List<T> getAny(Collection<T> collection, int... indexes)
T
- 元素类型collection
- 集合indexes
- 下标,支持负数@SafeVarargs public static <T> List<T> sortPageAll(int pageNo, int pageSize, Comparator<T> comparator, Collection<T>... colls)
BoundedPriorityQueue
实现分页取局部T
- 集合元素类型pageNo
- 页码,从0开始计数,0表示第一页pageSize
- 每页的条目数comparator
- 比较器colls
- 集合数组public static <T> List<T> sort(Collection<T> collection, Comparator<? super T> comparator)
T
- 集合元素类型collection
- 集合comparator
- 比较器public static <T> List<T> sort(List<T> list, Comparator<? super T> c)
T
- 元素类型list
- 被排序的Listc
- Comparator
Collections.sort(List, Comparator)
public static <T> List<T> sortByProperty(Collection<T> collection, String property)
T
- 元素类型collection
- 集合,会被转换为Listproperty
- 属性名public static <T> List<T> sortByProperty(List<T> list, String property)
T
- 元素类型list
- Listproperty
- 属性名public static List<String> sortByPinyin(Collection<String> collection)
collection
- 集合,会被转换为Listpublic static List<String> sortByPinyin(List<String> list)
list
- Listpublic static <K,V> TreeMap<K,V> sort(Map<K,V> map, Comparator<? super K> comparator)
K
- 键类型V
- 值类型map
- Mapcomparator
- Entry比较器TreeMap
public static <K,V> LinkedHashMap<K,V> sortToMap(Collection<Map.Entry<K,V>> entryCollection, Comparator<Map.Entry<K,V>> comparator)
K
- 键类型V
- 值类型entryCollection
- Entry集合comparator
- Comparator
LinkedList
public static <K,V> LinkedHashMap<K,V> sortByEntry(Map<K,V> map, Comparator<Map.Entry<K,V>> comparator)
K
- 键类型V
- 值类型map
- 被排序的Mapcomparator
- Comparator
LinkedList
public static <K,V> List<Map.Entry<K,V>> sortEntryToList(Collection<Map.Entry<K,V>> collection)
K
- 键类型V
- 值类型collection
- 被排序的Collection
public static <T> void forEach(Iterable<T> iterable, SerBiConsumer<Integer,T> consumer)
Iterable
,使用SerBiConsumer
接受遍历的每条数据,并针对每条数据做处理T
- 集合元素类型iterable
- Iterable
consumer
- SerBiConsumer
遍历的每条数据处理器public static <T> void forEach(Iterator<T> iterator, SerBiConsumer<Integer,T> consumer)
Iterator
,使用SerBiConsumer
接受遍历的每条数据,并针对每条数据做处理T
- 集合元素类型iterator
- Iterator
consumer
- SerBiConsumer
遍历的每条数据处理器public static <T> void forEach(Enumeration<T> enumeration, SerBiConsumer<Integer,T> consumer)
Enumeration
,使用SerBiConsumer
接受遍历的每条数据,并针对每条数据做处理T
- 集合元素类型enumeration
- Enumeration
consumer
- SerBiConsumer
遍历的每条数据处理器public static <K,V> void forEach(Map<K,V> map, SerConsumer3<Integer,K,V> kvConsumer)
SerConsumer3
接受遍历的每条数据,并针对每条数据做处理K
- Key类型V
- Value类型map
- Map
kvConsumer
- SerConsumer3
遍历的每条数据处理器MapUtil.forEach(Map, SerConsumer3)
public static <T> List<List<T>> group(Collection<T> collection, Hash32<T> hash)
Hash32
接口定义的hash算法,集合中的元素放入hash值对应的子列表中T
- 元素类型collection
- 被分组的集合hash
- Hash值算法,决定元素放在第几个分组的规则public static <T> List<List<T>> groupByField(Collection<T> collection, String fieldName)
T
- 元素类型collection
- 集合fieldName
- 元素Bean中的字段名,非Bean都放在第一个分组中public static <T> List<List<T>> groupByFunc(Collection<T> collection, Function<T,?> getter)
CollUtil.groupByFunc(list, TestBean::getAge)
T
- 元素类型collection
- 集合getter
- getter方法引用public static <K> Set<K> keySet(Collection<Map<K,?>> mapCollection)
K
- 键类型mapCollection
- Map列表public static <V> List<V> values(Collection<Map<?,V>> mapCollection)
V
- 值类型mapCollection
- Map列表public static <T extends Comparable<? super T>> T max(Collection<T> coll)
T
- 元素类型coll
- 集合Collections.max(Collection)
public static <T extends Comparable<? super T>> T min(Collection<T> coll)
T
- 元素类型coll
- 集合Collections.min(Collection)
public static <T> Collection<T> view(Collection<? extends T> c)
T
- 元素类型c
- 集合public static void clear(Collection<?>... collections)
collections
- 一个或多个集合public static <T> void padLeft(List<T> list, int minLen, T padObj)
T
- 集合元素类型list
- 列表minLen
- 最小长度padObj
- 填充的对象public static <T> void padRight(Collection<T> list, int minLen, T padObj)
T
- 集合元素类型list
- 列表minLen
- 最小长度padObj
- 填充的对象public static <F,T> Collection<T> trans(Collection<F> collection, Function<? super F,? extends T> function)
F
- 源元素类型T
- 目标元素类型collection
- 集合function
- 转换函数public static <E,K,V> void setValueByMap(Iterable<E> iterable, Map<K,V> map, Function<E,K> keyGenerate, BiConsumer<E,V> biConsumer)
E
- 元素类型K
- 替换的键V
- 替换的值iterable
- 集合map
- 映射集keyGenerate
- 映射键生成函数biConsumer
- 封装映射到的值函数public static int size(Object object)
object
- 可以为空的对象IllegalArgumentException
- 参数object不是Collection或者iteratorpublic static boolean isSub(Collection<?> subCollection, Collection<?> collection)
subCollection
- 第一个Iterable对象,即子集合。collection
- 第二个Iterable对象,可以为任何实现了Iterable接口的集合。public static boolean isEqualList(Collection<?> list1, Collection<?> list2)
Collection
是否元素和顺序相同,返回true
的条件是:
Collection
必须长度相同Collection
元素相同index的对象必须equals,满足Objects.equals(Object, Object)
list1
- 列表1list2
- 列表2public static boolean equals(Collection<?> coll1, Collection<?> coll2, boolean ignoreOrder)
Iterable
中的元素是否相同,可选是否判断顺序
当满足下列情况时返回true
:
Iterable
都为null
;Iterable
满足coll1 == coll2
;Iterable
所有具有相同下标的元素皆满足Objects.equals(Object, Object)
;coll1
- 集合1coll2
- 集合2ignoreOrder
- 是否忽略顺序public static <T,S extends T> boolean addIfAbsent(Collection<T> collection, S object)
null, null -> false [], null -> false null, "123" -> false ["123"], "123" -> false [], "123" -> true ["456"], "123" -> true [Animal{"name": "jack"}], Dog{"name": "jack"} -> true
T
- 集合元素类型S
- 要添加的元素类型【为集合元素类型的类型或子类型】collection
- 被加入的集合object
- 要添加到集合的对象public static <T> boolean anyMatch(Collection<T> collection, Predicate<T> predicate)
T
- 集合元素类型collection
- 集合predicate
- 自定义判断函数public static <T> boolean allMatch(Collection<T> collection, Predicate<T> predicate)
T
- 集合元素类型collection
- 集合predicate
- 自定义判断函数public static <T> List<T> flat(Collection<?> collection)
List<List<List<String>>> 解构成 List<String>
T
- 元素类型collection
- 需要解构的集合public static <T> List<T> flat(Collection<?> collection, boolean skipNull)
List<List<List<String>>> 解构成 List<String>
skipNull如果为true, 则解构后的集合里不包含null值,为false则会包含null值。
T
- 元素类型collection
- 需要结构的集合skipNull
- 是否跳过空的值Copyright © 2025. All rights reserved.