Collections是个操作
Set、List和Map
等集合的工具类
Collections工具类位于
java.util
包下
Collections中提供了一系列静态的方法对集合元素进行
排序、查询和修改
等操作
如果提供给它们的集合或类对象为null，则此类的方法都抛出一个
NullPointerException
addall方法
该方法可以向list集合中批量添加数据，返回类型为boolean
static boolean addAll(Collection<? super T> c, T… elements)
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 1, 2, 3, 45, 99, 21);
//list:[1,2,3,45,99,21]
asLifoQueue方法
该方法用于返回Deque作为后进先出Queue的视图 ，返回类型为Queue
static Queue asLifoQueue(Deque deque)
//创建一个数组双端队列对象(两端都可进出的队列)
Deque de = new ArrayDeque(10);
//将双端队列返回为后进先出的队列视图(类似于栈stack)
Queue lifo_q = Collections.asLifoQueue(de);
binarySearch方法
该方法用于利用二分法查找某个集合元素，而且这个集合必须实现List接口，集合必须有序，如果没有序，应该先排序再二分查找。如果要查找的元素的类型没有实现Comparable接口的compareTo方法进行排序，就还要提供一个比较器。
static int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
- java中提供的包装类型Integer,Sting等底层都为我们实现了Comparable接口，所以我们可以直接查找，不必再次去实现它
List<Integer> list = new ArrayList<>();
Collections.addAll(list, 1, 22, 23, 34, 45, 66, 88);
int pos = Collections.binarySearch(list, 22);//查找22的位置
- 如果是我们自定义的类排序且没有实现Comparable接口的话还要提供一个比较器
List<Student> list = new ArrayList<Student>();
list.add(new Student("1", "李四", 18));
list.add(new Student("5", "王五", 19));
list.add(new Student("2", "赵六", 17));
list.add(new Student("3", "小王", 20));
//定义比较器
Comparator comparator = new Comparator<Student>() {
@Override
//根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数
public int compare(Student o1, Student o2) {
//先根据年龄查找/排序，看是否相等
int num = s1.getAge() - s2.getAge();
//如果年龄相同再根据名字查找/排序，看是否相等
int num1 = (num == 0 ?
s1.getName().compareTo(s2.getName()) : num);
return num1;
}
};
//先排序
Collections.sort(list1, comparator);
//再二分查找
int index = Collections.binarySearch(
list,
new Student("5", "王五", 19),
comparator
);
//index的结果为 3
copy方法
该方法将所有元素从一个列表复制到另一个列表。执行此操作后，目标列表中每个已复制元素的索引将等同于源列表中该元素的索引。目标列表的长度至少必须等于源列表。如果目标列表更长一些，也不会影响目标列表中的其余元素
static void copy(List<? super T> dest,List<? extends T> src)
List<Integer> list = new ArrayList<>();//源列表
Collections.addAll(list, 1, 22, 23, 34, 45, 66, 88);
List<Integer> dest = new ArrayList<>(list.size());//目标列表
Collections.copy(dest,list);//将list的值复制到dest中
//结果dest:[1, 22, 23, 34, 45, 66, 88]
disJoint方法
该方法用于如果两个指定 collection 中没有相同的元素则返回 true，有则返回false
static boolean disjoint(Collection<?> c1, Collection<?> c2)
List<Integer> list1 = new ArrayList<>();
Collections.addAll(list1, 1, 22, 23, 34, 45, 66, 88);
List<Integer> list2 = new ArrayList<>();
Collections.addAll(list2, 33, 44, 55);
boolean disjoint = Collections.disjoint(list1, list2);
//结果为true，因为他们没有相同的元素
fill方法
该方法使用指定元素替换指定列表中的所有元素
static void fill(List<? super T> list ，T obj)
List<Integer> list = new ArrayList<>();
Collections.addAll(list, 1, 22, 23, 34, 45, 66, 88);
Collections.fill(list, 100);
//结果：[100, 100, 100, 100, 100]
list方法
该方法用于返回一个数组列表，该列表包含给定Enumeration返回的所有元素，以及将这些元素按枚举返回的顺序存储在ArrayList中的方式。
static ArrayList list(Enumeration e)
ArrayList arr = new ArrayList();
Stack st = new Stack();
st.push(10);
st.push(20);
st.push(30);
st.push(40);
st.push(50);
Enumeration en = st.elements();//枚举类型
arr = Collections.list(en);//转变赋值给list类型
max方法和min方法
该方法根据指定比较器产生的顺序，返回给定 collection 的最大/最小元素。collection 中的所有元素都必须可通过指定比较器 相互比较(也就是说,对于 collection 中的任意 e1 和 e2 元素,comp. compare(e1, e2) 不得抛出 ClassCastException)。
static T max(Collection<? extends T> coll,Comparator<? super T> comp)
static T min(Collection<? extends T> coll, Comparator<? super T> comp)
- 对java中提供的包装类型Integer,String(自带默认比较器)
List<Integer> list = new LinkedList<Integer>();
list.add(-1);
list.add(4);
list.add(-5);
list.add(1);
System.out.println("Max value is: "
+ Collections.max(list));
//结果为4
System.out.println("Min value is: "
+ Collections.min(list));
//结果为-5
- 当然我们也可以给包装类指定自定义的比较器
Comparator<String> strLenComparator = new Comparator<String>(){
@Override
public int compare(String s1, String s2) {
int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
//当主要条件相同一定要按照次要条件排序
if (num==0) {
return s1.compareTo(s2);
}
return num;
}
};
List<String> list=new ArrayList<>();
Collections.addAll(list, "jack", "jackson", "jk", "chengson");
int max=Collections.max(list,strLenComparator );
//结果为jackson
int min=Collections.min(list,strLenComparator);
//结果为jk
shuffle方法
该方法使用指定的随机源对指定列表进行置换。所有置换发生的可能性都是相等的，假定随机源是公平的
static void shuffle(List<?> list,Random rnd)
- 使用默认随机源Random
List<String> list = Arrays.asList("A", "B", "C", "D");
System.out.println("List before Shuffle : "+list);
Collections.shuffle(list);
System.out.println("List after shuffle : "+list);
//List before Shuffle : [A, B, C, D]
//List after shuffle : [A, C, D, B]
- 使用自定义随机源Random
LinkedList<Integer> list = new LinkedList<Integer>();
list.add(45);
list.add(20);
list.add(55);
list.add(90);
list.add(15);
System.out.println("List before Shuffle = "+list);
Collections.shuffle(list, new Random());
System.out.println("Shuffled List with Random() = "+list);
Collections.shuffle(list, new Random(3));
System.out.println("Shuffled List with Random(3) = "+list);
//List before Shuffle = [45, 20, 55, 90, 15]
//Shuffled List with Random() = [55, 90, 15, 45, 20]
//Shuffled List with Random(3) = [45, 90, 55, 15, 20]
reverse方法
该方法反转指定列表中元素的顺序
static void reverse(List<?> list)
List < Integer > arr = new ArrayList < Integer > ();
arr.add(10);
arr.add(20);
arr.add(30);
arr.add(40);
arr.add(50);
System.out.println("Array List : " + arr);
Collections.reverse(arr);
System.out.println("Collections.reverse(arr): " + arr);
//Array List : [10, 20, 30, 40, 50]
//Collections.reverse(arr_l): [50, 40, 30, 20, 10]
reverseOrder方法
该方法返回一个比较器，它强行逆转指定比较器的顺序。如果指定比较器为 null，则此方法等同于 reverseOrder()(换句话说，它返回一个比较器，该比较器将强行逆转实现了 Comparable 接口的对象 collection 的 自然顺序）。
static Comparator reverseOrder(Comparator cmp)
- 比较器为空时，逆转默认实现了 Comparable 接口的对象 collection 的 自然顺序
List<Integer> list = Arrays.asList(2, 1, 4, 3);
Collections.sort(list);
//list:[1,2,3,4]
Collections.sort(list, Collections.reverseOrder());
//list:[4,3,2,1]
- 比较器不为空时，逆转比较器的排序规则排序
Comparator<String> strLenComparator = new Comparator<String>(){
@Override
public int compare(String s1, String s2) {
int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
//当主要条件相同一定要按照次要条件排序
if (num==0) {
return s1.compareTo(s2);
}
return num;
}
};
List<String> list = Arrays.asList("aaa", "bbbbb", "c", "ddd");
Collections.sort(list, strLenComparator );
//list:['c', 'aaa', 'ddd', 'bbbbb']
Collections.sort(list, Collections.reverseOrder( strLenComparator));
//list:['bbbbb','ddd','aaa','c']
sort方法
该方法根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器 相互比较(也就是说，对于列表中的任意 e1 和 e2 元素， c.compare(e1, e2) 不得抛出 ClassCastException）。
static void sort(List list,Comparator<? super T> c)
- 通过自定义比较器实现自定义比较规则
ArrayList<students> stu = new ArrayList<>();
stu.add(new students("rank",20));
stu.add(new students("Jack",16));
stu.add(new students("Tom",18));
/*使用匿名内部类创建Comparator接口的对象作为参数
匿名内部类：直接通过接口名称创建对象，省去接口的实现类
其格式为：接口名称 对象名 = new 接口名称 () {覆盖重写接口的所有抽象方法}
*/
Collections.sort(stu, new Comparator<students>() {
@Override
public int compare(students o1, students o2) {
return o1.getAge()-o2.getAge(); //根据age进行升序排序
}
});
System.out.println(stu);
- 通过实现Comparable接口的compareTo方法自定义比较规则
class person implements Comparable<person> { //实现comparable接口
private String name;
private int age;
public person(String name, int age) {
this.name = name;
this.age = age;
}
public person() {
}
//省略get、set和toString方法
@Override
public int compareTo(person o) { //重写compareTo方法
return this.getAge()-o.getAge(); // 根据age进行升序排序，若反过来则是降序
}
}
//主函数内容
ArrayList<person> list1=new ArrayList<>();
list1.add(new person("张三",25));
list1.add(new person("李四",20));
list1.add(new person("王五",20));
Collections.sort(list1);
System.out.println(list1);
swap方法
该方法在指定列表的指定位置处交换元素。（如果指定位置相同，则调用此方法不会更改列表。)
static void swap(List<?> list,int i,int j)
//参数
//list - 进行元素交换的列表。
//i - 要交换的一个元素的索引。
//j - 要交换的另一个元素的索引。
ArrayList arrayList = new ArrayList();
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
arrayList.add("E");
System.out.println("Before swaping, ArrayList contains : " + arrayList);
Collections.swap(arrayList,0,4);
System.out.println("After swaping, ArrayList contains : " + arrayList);
//Before swaping, ArrayList contains : [A, B, C, D, E]
//After swaping, ArrayList contains : [E, B, C, D, A]
rotate方法
该方法根据指定的距离轮换指定列表中的元素.调用此方法后,对于 0 和 list.size() -1(包括)之间的所有 i 值，索引 i 处的元素将是以前位于索引 (i – distance) mod list.size() 处的元素.(此方法对列表的大小没有任何影响)
public static void rotate(List<?> list, int distance)
List < Integer > arr_l = new ArrayList < Integer > ();
int dis = 4;
arr_l.add(10);
arr_l.add(20);
arr_l.add(30);
arr_l.add(40);
arr_l.add(50);
arr_l.add(60);
arr_l.add(70);
arr_l.add(80);
arr_l.add(90);
arr_l.add(100);
System.out.println("Array List: " + arr_l);
Collections.rotate(arr_l, dis);
System.out.println("Collections.rotate(arr_l,dis): " + arr_l);
//Array List: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
//所有元素向右循环移动四位
//Collections.rotate(arr_l,dis): [70, 80, 90, 100, 10, 20, 30, 40, 50, 60]
replaceAll方法
该方法使用另一个值替换列表中出现的所有某一指定值。更确切地讲，使用 newVal 替换 list 中满足 (oldVal == null ?e ==null : oldVal.equals(e)) 的每个 e 元素。（此方法对列表的大小没有任何影响。）
static boolean replaceAll(List list,T oldVal,T newVal)
List < Integer > l = new ArrayList < Integer > ();
l.add(10);
l.add(20);
l.add(30);
l.add(40);
l.add(50);
l.add(30);
System.out.println("List: " + l);
Collections.replaceAll(l, 30, 300);
System.out.println("Collections.replaceAll(l,30,300): " + l);
//List: [10, 20, 30, 40, 50, 30]
//将list中所有值30替换为值300
//Collections.replaceAll(l,30,300): [10, 20, 300, 40, 50, 300]
其他
| 方法 | 描述 |
|---|---|
|
static int indexOfSubList(List<?> source, List<?> target) |
返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。 |
|
static Set newSetFromMap(Map<E,Boolean> map) |
得到的 set 与传入map底层实现映射有相同的顺序、并发性和性能特征 |
|
static int frequency(Collection<?> c, Object o) |
返回指定 collection 中等于指定对象的元素数。 |
|
public static List nCopies(int n,T o) |
返回由指定对象的n副本组成的不可变列表。 |