1.CollectionUtils
1.Collections.sort(list);//升序
2.Collections.reverse(list);//降序 注意：单独使用只会根据插入顺序反过来排序，需要结合升序一起使用
3.Collections.max(list);//获取最大值
4.Collections.min(list);//获取最小值
5.Collections.emptyList();//空集合
6.Collections.binarySearch(list, 3);//二分查找要查找某个元素，必须提供集合，而且这个集合必须实现List接口集合必须有序，如果没有序，应该先排序再二分查找如果要查找的元素的类型没有实现Comparable接口的compareTo方法进行排序，就还要提供一个比较器。（此处说明的是二分查找的2种方式）例如：import java.util.Arrays;import java.util.Collections;import java.util.List;class tea implements Comparable<tea>{private int id;public tea(int id){this.id=id;}public int getId() {return id;}@Overridepublic String toString() {return id+"";}@Overridepublic int compareTo(tea o) {return o.getId()-id;}}public class Main {public static void main(String[] s) {tea[] arr = {new tea(2), new tea(3), new tea(1),new tea(5)};List<tea> list = Arrays.asList(arr);System.out.println(list);Collections.sort(list);System.out.println(list);int i= Collections.binarySearch(list,new tea(3));System.out.println(i);}}结果：[2,3,1,5][1,2,3,5]2
7.Collections.unmodifiableList(list);//转换成不可修改集合Collections.unmodifiableList() 方法，让 getter 方法返回一个不可被修改的UnmodifiableList 集合容器，而这个容器类重写了 List 容器中跟修改数据相关的方法，比如 add()、clear() 等方法。一旦我们调用这些修改数据的方法，代码就会抛出UnsupportedOperationException 异常，这样就避免了容器中的数据被修改List<Integer> integers = Collections.unmodifiableList(list);//转换成不可修改集合integers.add(1);异常信息：Exception in thread "main" java.lang.UnsupportedOperationExceptionat java.util.Collections$UnmodifiableCollection.add(Collections.java:1055)at DateTest.main(DateTest.java:29)
2.转换线程安全集合
可以用Collections的synchronizedxxx方法，将线程不安全的集合，直接转换成线程安全集合。
List<Integer> list = new ArrayList<>();list.add(2);list.add(1);list.add(3);List<Integer> integers = Collections.synchronizedList(list);//将ArrayList转换成线程安全集合System.out.println(integers);它的底层会创建SynchronizedRandomAccessList或者SynchronizedList类，这两个类的很多方法都会用synchronized加锁
3.更多
CollectionUtils.addAll(strList, strArray);//添加数组到集合ex:String[] strArray = {"aaa", "bbb", "ccc"};List strList = new ArrayList();CollectionUtils.addAll(strList, strArray);[aaa, bbb, ccc]
CollectionUtils.isEmpty(list);//集合判空，只对Collection及子类有效
CollectionUtils.isNotEmpty(list);//集合判不为空，只对Collection及子类有效
CollectionUtils.addIgnoreNull(list3, 1);//如果1处不为null，把1添加到list3集合中
CollectionUtils.removeAll(list1, list2);//从list1中删除list2
CollectionUtils.union(list, list2);//获取并集
CollectionUtils.intersection(list, list2);//获取交集
CollectionUtils.disjunction(list, list2);//获取交集的补集
CollectionUtils.subtract(list, list2);//获取差集
CollectionUtils.retainAll(list1, list2);//返回list2在list1中的数据
CollectionUtils.reverseArray(arr);//数组反转
CollectionUtils.getCardinalityMap(list1); //返回每个元素出现的个数
CollectionUtils.cardinality("9", list2) //返回对象在集合中出现的次数
CollectionUtils.get(list2, 0) //返回结合指定位置的数
CollectionUtils.isEqualCollection(list1, list2);//判断两个集合是否相等
CollectionUtils.isProperSubCollection(testList2,testList);//判断集合1是否小于集合2
CollectionUtils.isSubCollection(testList2, testList);//判断是否存在交集
CollectionUtils.containsAny(list1, list2)//判断是否存在交集
CollectionUtils.select：根据条件筛选集合元素
CollectionUtils.transform：根据指定方法处理集合元素，类似List的map()
CollectionUtils.find：基本和select一样
CollectionUtils.forAllDo：调用每个元素的指定方法
CollectionUtils.isEqualCollection：判断两个集合是否一致
一、对集合中某些些元素进行操作，并返回操作后的元素集合Collection collect = CollectionUtils.collect(list2.iterator(), input -> {return input += "a";});Collection collect2 = CollectionUtils.collect(list2, input -> {return input += "a";});
二、集合中某些些元素进行操作，并将操作后的元素封装带第3个参数集合中，第3个集合返回Collection collect = CollectionUtils.collect(list2.iterator(), input -> {return input += "a";},new ArrayList());Collection collect2 = CollectionUtils.collect(list2, input -> {return input += "a";},new ArrayList());
三、条件过滤，如果testList为null，不进行任何操作CollectionUtils.filter(testList, itm->{return Integer.valueOf(itm.toString())>2;});
四、返回符合条件的个数int resultMatchNum= CollectionUtils.countMatches(testList, itm->{return Integer.valueOf(itm.toString())>1;});
五、判断是否存在符合条件的元素boolean resultExists=CollectionUtils.exists(testList, itm->{return Integer.valueOf(itm.toString())>2;});
六、返回符合条件的数据，注意:只返回一个Object reusltFindObject=CollectionUtils.find(testList, itm->{return Integer.valueOf(itm.toString())>1;});
七、返回符合条件的数据，返回一个集合Collection resultSelect=CollectionUtils.select(testList, itm->{return Integer.valueOf(itm.toString())>1;});
八、返回符合条件的数据，并封装到传入的集合中CollectionUtils.select(testList, itm->{return Integer.valueOf(itm.toString())>1;}, testList2);
九、和select结果相反，返回不符合条件的collectionCollection resultSelectReject=CollectionUtils.selectRejected(testList, itm->{return Integer.valueOf(itm.toString())>1;});
十、和select结果相反，将不符合条件的元素，封装到传入的集合Collection resultSelectReject=CollectionUtils.selectRejected(testList, itm->{return Integer.valueOf(itm.toString())>1;});
十一、断言，都符合返回集合，否则返回 java.lang.IllegalArgumentException 异常Collection resultCollect=CollectionUtils.predicatedCollection(testList, itm->{return Integer.valueOf(itm.toString())>1;});
十二、对每个元素进行操作，操作直接影响传入的集合CollectionUtils.transform(list1, input -> input+"@");
更全
addAll
添加数组数据到集合
String[] strArray = {"aaa", "bbb", "ccc"};
List strList = new ArrayList();
CollectionUtils.addAll(strList, strArray);
[aaa, bbb, ccc]
addAll
添加集合数据到另一个集合
List<String> list = Arrays.asList(new String[]{"AAA", "BBB", "CCC"});
List<String> list1 = new ArrayList<>();
CollectionUtils.addAll(list1, list.iterator());
[AAA, BBB, CCC]
addAll
添加集合数据到另一个集合
// Hashtable ht = new Hashtable();
// ht.put("1", "One");
// ht.put("2", "Two");
// ht.put("3", "Three");
Vector<String> ht = new Vector<String>();
ht.add("One");
ht.add("Two");
ht.add("Three");
List<Map<String,String>> list3 = new ArrayList<>();
CollectionUtils.addAll(list3,ht.elements());
[One, Two, Three]
addIgnoreNull
添加数据到集合，忽略null值
CollectionUtils.addIgnoreNull(list1, null);
[]
List<String> list1 = Arrays.asList(new String[]{"1", "4", "6", "7"});
List<String> list2 = Arrays.asList(new String[]{"6", "9"});
removeAll
删除元素集合
Collection collection = CollectionUtils.removeAll(list1, list2);
[1, 4, 7]
List<String> list1 = Arrays.asList(new String[]{"1", "4", "6", "7"});
List<String> list2 = Arrays.asList(new String[]{"1", "3", "6", "9"});
union
并集
CollectionUtils.union(list1, list2);
[1, 3, 4, 6, 7, 9]
intersection
交集
CollectionUtils.intersection(list1, list2)
[1, 6]
disjunction
交集的补集
CollectionUtils.disjunction(list1, list2);
[3, 4, 7, 9]
subtract
差集
CollectionUtils.subtract(list1, list2);
[4, 7]
retainAll
返回集合2在集合1所存在的数据，返回的是一个新的集合
Collection collection = CollectionUtils.retainAll(list1, list2);
[1, 6]
reverseArray
数组反转
String[] arr = new String[]{"1", "4", "6", "7"};
CollectionUtils.reverseArray(arr);
["7","6","4","1"]
List<String> list1 = Arrays.asList(new String[]{"1", "4", "6", "7"});
getCardinalityMap
返回每个元素出现的个数
Map<String,String> cardinalityMap = CollectionUtils.getCardinalityMap(list1);
[1, 6]
cardinality
返回对象在集合中出现的次数
int cardinality = CollectionUtils.cardinality("9", list2);
1
forAllDo
对集合中的每个元素执行给定的闭包，如果输入集合或闭包为null，则不会进行任何更改。
get
获取集合、Map，数组指定索引处远处
Object o = CollectionUtils.get(list2, 3);
9
collect
对集合中某些些元素进行操作，并返回操作后的元素集合
Collection collect = CollectionUtils.collect(list2.iterator(), input -> {
return input += "a";
});
Collection collect2 = CollectionUtils.collect(list2, input -> {
return input += "a";
});
[2a, 3a, 61a, 9a]
collect
对集合中某些些元素进行操作，并将操作后的元素封装带第3个参数集合中，第3个集合返回
Collection collect = CollectionUtils.collect(list2.iterator(), input -> {
return input += "a";
},new ArrayList());
Collection collect2 = CollectionUtils.collect(list2, input -> {
return input += "a";
},new ArrayList());
[2a, 3a, 61a, 9a]
isEmpty
判断集合是否为空，只对Collection及子类有效
CollectionUtils.isEmpty(new Array<String>());
true
isNotEmpty
判断集合是否不为空，只对Collection及子类有效
CollectionUtils.isNotEmpty(new Array<String>());
false
sizeIsEmpty
检查指定的collection / array / iterator是否为空。
CollectionUtils.sizeIsEmpty(new ArrayList<String>())
true
isEqualCollection
判断两个集合是否相等
CollectionUtils.isEqualCollection(list1, list2);
false
isProperSubCollection
判断集合1是否小于集合2
List<Integer> testList = Arrays.asList(new Integer[]{1, 2, 3});
List<Integer> testList2 = new ArrayList<Integer>(0){
{
add(1);
}
};
CollectionUtils.isProperSubCollection(testList2,testList);true
isSubCollection
判断集合1和集合2是否存在交集
List<Integer> testList = Arrays.asList(new Integer[]{1, 2, 3});
List<Integer> testList2 = new ArrayList<Integer>(0){
{
add(1);
}
};
CollectionUtils.isSubCollection(testList2, testList);
true
List<String> decorate = FixedSizeList.decorate(Arrays.asList("zhong", "guo", "ren"))
maxSize
返回集合最大大小，此方法使用BoundedCollection接口来确定完整状态。如果集合未实现此接口，则返回false。CollectionUtils.maxSize(decorate)
3
isFull
判断集合是否是一个固定长度的集合，此方法使用BoundedCollection接口确定最大大小。如果集合未实现此接口，则返回-1。
CollectionUtils.isFull(decorate)
true
List<String> list1 = Arrays.asList(new String[]{"1", "4", "6", "7"});
List<String> list2 = Arrays.asList(new String[]{"1", "3", "6", "9"});
containsAny
判断两个集合是否存在交集
CollectionUtils.containsAny(list1, list2)
true
List<String> list1 = Arrays.asList(new String[]{"1", "2", "3"});
filter
条件过滤，如果testList为null，不进行任何操作
CollectionUtils.filter(testList, itm->{
return Integer.valueOf(itm.toString())>2;
});
[3] // tesetList
countMatches
返回符合条件的个数
int resultMatchNum= CollectionUtils.countMatches(testList, itm->{
return Integer.valueOf(itm.toString())>1;
});
2 // resultMatchNum
exists
判断是否存在符合条件的元素
boolean resultExists=CollectionUtils.exists(testList, itm->{
return Integer.valueOf(itm.toString())>2;
});true // resultExists
find
返回符合条件的数据，注意:只返回一个
Object reusltFindObject=CollectionUtils.find(testList, itm->{
return Integer.valueOf(itm.toString())>1;
});2 // resultFindObject
select
返回符合条件的数据，返回一个集合
Collection resultSelect=CollectionUtils.select(testList, itm->{
return Integer.valueOf(itm.toString())>1;
});
[2, 3] // resultSelect
select
返回符合条件的数据，并封装到传入的集合中
List<Integer> testList2 = new ArrayList<Integer>(){
{
add(1);
}
};
CollectionUtils.select(testList, itm->{
return Integer.valueOf(itm.toString())>1;
}, testList2);[1, 2, 3] // testList2
selectRejected
和select结果相反，返回不符合条件的collection
Collection resultSelectReject=CollectionUtils.selectRejected(testList, itm->{
return Integer.valueOf(itm.toString())>1;
});
[1] // resultSelectReject
selectRejected
和select结果相反，将不符合条件的元素，封装到传入的集合
List<Integer> testList2 = new ArrayList<Integer>(){
{
add(1);
}
};
Collection resultSelectReject=CollectionUtils.selectRejected(testList, itm->{
return Integer.valueOf(itm.toString())>1;
});
[1, 1] // resultSelectReject
predicatedCollection
断言，都符合返回集合，否则返回 java.lang.IllegalArgumentException 异常
Collection resultCollect=CollectionUtils.predicatedCollection(testList, itm->{
return Integer.valueOf(itm.toString())>1;
});[1, 2, 3] // resultCollect
transform
对每个元素进行操作，操作直接影响传入的集合
CollectionUtils.transform(list1, input -> input+"@");
["1@","4@","6@","7@"]
synchronizedCollection
返回同步的集合
Collection collection = CollectionUtils.synchronizedCollection(new ArrayList());
unmodifiableCollection
对复制一份不可修改的集合，原集合改变，则集合改变，但复制的集合不可修改添加
Collection<String> c = new ArrayList<>();
Collection<String> s = CollectionUtils.unmodifiableCollection(c);
c.add("boy");
c.add("love");
c.add("girl");
// s.add("have a error");报错
System.out.println(s);
[boy, love, girl]
二、ArrayUtils
ArrayUtils.toString(new int[] { 1, 4, 2, 3 });// {1,4,2,3} 将一个数组转换成String,用于打印数组
ArrayUtils.EqualsBuilder(array1,array2) //只有当两个数组的数据类型,长度,数值顺序都相同的时候,该方法才会返回True
ArrayUtils.equal(array1,array2)一、// 两个数组完全相同ArrayUtils.isEquals(new int[] { 1, 2, 3 }, new int[] { 1, 2, 3 });// true二、// 数据类型以及长度相同,但各个Index上的数据不是一一对应ArrayUtils.isEquals(new int[] { 1, 3, 2 }, new int[] { 1, 2, 3 });// true三、// 数组的长度不一致ArrayUtils.isEquals(new int[] { 1, 2, 3, 3 }, new int[] { 1, 2, 3 });// false四、// 不同的数据类型ArrayUtils.isEquals(new int[] { 1, 2, 3 }, new long[] { 1, 2, 3 });// falseArrayUtils.isEquals(new Object[] { 1, 2, 3 }, new Object[] { 1, (long) 2, 3 });// false五、// Null处理,如果输入的两个数组都为null时候则返回trueArrayUtils.isEquals(new int[] { 1, 2, 3 }, null);// falseArrayUtils.isEquals(null, null);// trueArrayUtils.clone(new int[] { 3, 2, 4 });// {3,2,4}，拷贝数组截取数组ArrayUtils.subarray(new int[] { 3, 4, 1, 5, 6 }, 2, 4);// {1,5}// 起始index为2(即第三个数据)结束index为4的数组ArrayUtils.subarray(new int[] { 3, 4, 1, 5, 6 }, 2, 10);// {1,5,6}// 如果endIndex大于数组的长度,则取beginIndex之后的所有数据ArrayUtils.isSameLength(new Integer[] { 1, 3, 5 }, new Long[] { 2L, 8L, 10L });// true，判断两个数组的长度是否相等ArrayUtils.getLength(new long[] { 1, 23, 3 })//获得数组的长度ArrayUtils.isSameType(new int[] { 1, 3 }, new long[] { 8, 5, 6 });// false,判段两个数组的类型是否相同ArrayUtils.reverse(array)//数组反转//查询某个Object在数组中的位置,可以指定起始搜索位置,找不到返回-1// 从正序开始搜索,搜到就返回当前的index否则返回-1ArrayUtils.indexOf(new int[] { 1, 3, 6 }, 6);// 2ArrayUtils.indexOf(new int[] { 1, 3, 6 }, 2);// -1// 从逆序开始搜索,搜到就返回当前的index否则返回-1ArrayUtils.lastIndexOf(new int[] { 1, 3, 6 }, 6);// 2ArrayUtils.contains(new int[] { 3, 1, 2 }, 1);// true，查询某个Object是否在数组中//基本数据类型与包装类互转
ArrayUtils.toObject(new int[] { 1, 2 });// new Integer[]{Integer,Integer}
ArrayUtils.toPrimitive(new Integer[] { new Integer(1), new Integer(2) });// new int[]{1,2} //判断数组是否为空(null和length=0的时候都为空)
ArrayUtils.isEmpty(new int[0]);// true
ArrayUtils.isEmpty(new Object[] { null });// false ArrayUtils.addAll(new int[] { 1, 3, 5 }, new int[] { 2, 4 });// {1,3,5,2,4} //合并两个数组
ArrayUtils.add(new int[] { 1, 3, 5 }, 4);// {1,3,5,4},添加一个数据到数组
ArrayUtils.remove(new int[] { 1, 3, 5 }, 1);// {1,5},删除数组中某个位置上的数据
ArrayUtils.removeElement(new int[] { 1, 3, 5 }, 3);// {1,5},删除数组中某个对象(从正序开始搜索,删除第一个)三、Arrays
// (1) 创建一维数组， 三种创建方式int[] iarr=new int[20];String[] sarr={"a","b","c","d"};double[] darr=new double[]{1.0,3.0,2.0};Integer[] Iarr={1,2,3,4};// (2) 创建二维数组: 维度固定与可变维度int[][] iiarr=new int[20][20];String[][] ssarr=new String[3][];ssarr[0]=new String[3];ssarr[1]=new String[4];ssarr[2]=new String[5];// (3) 数组赋初值Arrays.fill(iarr,1);// (3) 打印数组元素 Arrays.toString(arr) [arr[0],arr[1]...arr[n]]System.out.println(Arrays.toString(darr));// (4) 数组排序Arrays.sort(darr);System.out.println(Arrays.toString(darr));// (5) 数组Array转换为集合Collection: 使用Arrays.asList方法转变为list,再初始化集合ArrayList<String> sal=new ArrayList<String>(Arrays.asList(sarr));HashSet<String> shs=new HashSet<>(Arrays.asList(sarr));LinkedList<String> sll=new LinkedList<>(Arrays.asList(sarr));// 注意： 集合需要使用Integer等类型，而不是int等基本类型 故int数组需要先转换为Integer类型ArrayList<Integer> ial=new ArrayList<>(Arrays.asList(ArrayUtils.toObject(iarr)));// (6) 集合转换为数组: 先定义数组arr，再Collection.toArray(arr)为数组赋值String[] sarr3=new String[sal.size()];sal.toArray(sarr3);// (7) 合并两个数组 ArrayUtils.addAll(arr1,arr2);// (8) 数组反序 ArrayUtils.reverse(sarr3);// (9) 移除元素 ArrayUtils.remove(sarr3,3);/* Arrays类方法Arrays.toString(arr) 以字符串形式展示数组元素Arrays.asList(arr) 将数组转化为一个列表Arrays.fill(arr,val) 将数组中所有元素都赋值为valArrays.sort(arr) 数组元素排序Arrays.equals(arr1,arr2) 判断两个数组(元素)是否相同Arrays.binarySearch(arr,target) 在数组中二分查找元素targetArrays.binarySearch(arr,begin,end,target) 在数组中从begin到end区间二分查找targetArrays.copyOf(arr,arr.length) 数组复制*//* ArrayUtils类方法ArrayUtils.add(arr,val) 数组末尾位置添加元素ArrayUtils.add(arr,index,val) 数组指定位置处添加元素ArrayUtils.addAll(arr1,arr2) 两个数组元素相加;ArrayUtils.clone(arr1) 数组拷贝;ArrayUtils.reverse(arr1) 数组反转/逆序;ArrayUtils.contains(arr1,val) 数组中是否包含特定值;ArrayUtils.indexOf(arr1,val) 指定元素在数组中第一次出现位置;ArrayUtils.indexOf(arr1,val,start) 从start位置开始查找,指定元素在数组中第一次出现位置;ArrayUtils.lastIndexOf(arr1,val) 指定元素在数组中最后一次出现位置;ArrayUtils.lastIndexOf(arr1,val,start) 从start位置开始查找,指定元素在数组中最后一次出现位置;ArrayUtils.remove(arr,pos) 删除指定下标的元素;ArrayUtils.removeElement(arr,val) 删除数组中指定元素(第一次出现位置);ArrayUtils.subarray(arr1,start,end) 截取数组 左闭右开;// 基本数据类型数组转换为对应封装类型数组Integer[] arr_Integer=ArrayUtils.toObject(new int[]{1,2,3});// 包装数据类型数组转换为对应的基本数据类型数组int[] arr_int=ArrayUtils.toPrimitive(arr_Integer);*/