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;
}
@Override
public String toString() {
return id+"";
}
@Override
public 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.UnsupportedOperationException
at 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结果相反，返回不符合条件的collection
Collection 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+"@");
二、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 });// false
ArrayUtils.isEquals(new Object[] { 1, 2, 3 }, new Object[] { 1, (long) 2, 3 });// false
五、// Null处理,如果输入的两个数组都为null时候则返回true
ArrayUtils.isEquals(new int[] { 1, 2, 3 }, null);// false
ArrayUtils.isEquals(null, null);// true
ArrayUtils.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否则返回-1
ArrayUtils.indexOf(new int[] { 1, 3, 6 }, 6);// 2
ArrayUtils.indexOf(new int[] { 1, 3, 6 }, 2);// -1
// 从逆序开始搜索,搜到就返回当前的index否则返回-1
ArrayUtils.lastIndexOf(new int[] { 1, 3, 6 }, 6);// 2
ArrayUtils.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) 将数组中所有元素都赋值为val
Arrays.sort(arr) 数组元素排序
Arrays.equals(arr1,arr2) 判断两个数组(元素)是否相同
Arrays.binarySearch(arr,target) 在数组中二分查找元素target
Arrays.binarySearch(arr,begin,end,target) 在数组中从begin到end区间二分查找target
Arrays.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);
*/
358
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
