Java 中Collections类的用法
参考：
Collections类常用方法总结
1. sort
对集合进行排序
public static > void sort(List list)
public static void sort(List list, Comparator c)
在使用List时想根据List中存储对象的某一字段进行排序，那么我们要用到Collections.sort方法对list排序，用Collections.sort方法对list排序有两种方法：
- 第一种是list中的对象实现Comparable接口；
- 第二种方法是根据Collections.sort重载方法来实现。
demo：
public class SortTest {
public static void main(String[] args) {
List listS = new ArrayList();
List list1 = new ArrayList();
List list2 = new ArrayList();
List list3 = new ArrayList();
//一.将String类型的变量插入到listS中并排序
//listS中的对象String 本身含有compareTo方法，所以可以直接调用sort方法，按自然顺序排序，即升序排序
listS.add("5");
listS.add("2");
listS.add("9");
Collections.sort(listS);
//二.将Employer1类的对象插入到list1中并排序
//将已创建的实现了Comparator接口的比较类MyCompare传入Collections的sort方法中即可实现依照MyCompare类中的比较规则。
Employer1 a1 = new Employer1();
Employer1 b1 = new Employer1();
Employer1 c1 = new Employer1();
a1.setName("a1"); a1.setAge(44);
b1.setName("b1"); b1.setAge(55);
c1.setName("b1"); c1.setAge(33);
list1.add(a1);
list1.add(b1);
list1.add(c1);//Collections类的sort方法要求传入的第二个参数是一个已实现Comparator接口的比较器
Collections.sort(list1, new MyCompare());
//三.将Employer2类的对象插入到list2中并排序
//其实原理和上面的二类似，只是没有单独创建MyCompare类，而是用匿名内部类来实现Comparator接口里面的具体比较。
Employer2 a2 = new Employer2();
Employer2 b2 = new Employer2();
Employer2 c2 = new Employer2();
a2.setName("a2"); a2.setAge(66);
b2.setName("b2"); b2.setAge(33);
c2.setName("b2"); c2.setAge(22);
list2.add(a2);
list2.add(b2);
list2.add(c2); //Collections类的sort方法要求传入的第二个参数是一个已实现Comparator接口的比较器
Collections.sort(list2,new Comparator(){
@Override
public int compare(Employer2 a2, Employer2 b2) {
return a2.getOrder().compareTo(b2.getOrder());
}
});
//四.将Employer3类的对象插入到list3中并排序
//被排序的类Employer3实现了Comparable接口,在类Employer3中通过重载compareTo方法来实现具体的比较。
Employer3 a3 = new Employer3();
Employer3 b3 = new Employer3();
Employer3 c3 = new Employer3();
a3.setName("a3"); a3.setAge(77);
b3.setName("b3"); b3.setAge(55);
c3.setName("b3"); c3.setAge(99);
list3.add(a3);
list3.add(b3);
list3.add(c3);
Collections.sort(list3);//Collections类的sort方法要求传入的List中的对象是已实现Comparable接口的对象
System.out.println(listS);
System.out.println(list1);
System.out.println(list3);
System.out.println(list2);
}
}
class Employer1{
private String name;
private Integer age;
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override//重载了Object类里的toString方法，使之可以按照我们要求的格式打印
public String toString() {
return "name is "+name+" age is "+ age;
}
}
class MyCompare implements Comparator {
@Override//重载了Comparator接口里面的compare方法实现具体的比较
public int compare(Employer1 o1, Employer1 o2) {
return o1.getAge().compareTo(o2.getAge());
}
}
class Employer2{
private String name;
private Integer age;
public void setName(String name) {
this.name = name;
}
public Integer getOrder() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override//重载了Object类里的toString方法，使之可以按照我们要求的格式打印
public String toString() {
return "name is "+name+" age is "+age;
}
}
class Employer3 implements Comparable{
private String name;
private Integer age;
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override//重载了Object类里的toString方法，使之可以按照我们要求的格式打印
public String toString() {
return "name is "+name+" age is "+age;
}
@Override//重载了Comparable接口里的compareTo方法来实现具体的比较
public int compareTo(Employer3 a) {
return this.age.compareTo(a.getAge());
}
} 打印结果：
[2, 5, 9]
[name is b1 age is 33, name is a1 age is 44, name is b1 age is 55]
[name is b3 age is 55, name is a3 age is 77, name is b3 age is 99]
[name is b2 age is 22, name is b2 age is 33, name is a2 age is 66]compareTo()小结
由上面的程序我们可以看出，无论是实现了Comparable接口的方法还是实现了Comparator接口的方法，最终比较的返回值都是通过compareTo方法实现的，故就把compareTo方法单独拿出来做个小结。
compareTo()的返回值是整型，它是先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的差值，如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推，直至比较的字符或被比较的字符有一方全比较完，这时就比较字符的长度。例如：
String s1 = "abc";
String s2 = "abcd";
String s3 = "abcdfg";
String s4 = "1bcdfg";
String s5 = "cdfg";
System.out.println( s1.compareTo(s2) ); // -1 (前面相等,s1长度小1)
System.out.println( s1.compareTo(s3) ); // -3 (前面相等,s1长度小3)
System.out.println( s1.compareTo(s4) ); // 48 ("a"的ASCII码是97,"1"的的ASCII码是49,所以返回48)
System.out.println( s1.compareTo(s5) ); // -2 ("a"的ASCII码是97,"c"的ASCII码是99,所以返回-2)2. shuffle
对集合进行随机排序
public static void shuffle(List list)
public static void shuffle(List list, Random rnd)demo：
public class Practice {
public static void main(String[] args){
List c = new ArrayList();
c.add("w");
c.add("o");
c.add("r");
c.add("l");
c.add("d");
System.out.println(c);
Collections.shuffle(c);
System.out.println(c);
Collections.shuffle(c);
System.out.println(c);
}
}结果：
[w, o, r, l, d]
[l, d, w, o, r]
[o, r, d, l, w]
3. binarySearch
查找指定集合中的元素，返回所查找元素的索引，如果它包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。 插入点 被定义为将键插入数组的那一点：即第一个大于此键的元素索引，如果数组中的所有元素都小于指定的键，则为 a.length。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
public static int binarySearch(List> list, T key)
public static int binarySearch(List list, T key, Comparator c) demo：
public class Practice {
public static void main(String[] args){
List c = new ArrayList();
c.add("l");
c.add("o");
c.add("v");
c.add("e");
System.out.println(c);
int m = Collections.binarySearch(c, "o");
int n = Collections.binarySearch(c, "p");
System.out.println(m + " " + n);
}
}结果:
[l, o, v, e]
1 -34. max
public static > T max(Collectioncoll)
public static T max(Collection coll,Comparator comp) 前者采用Collection内含自然比较法，后者采用Comparator进行比较.
5. min
public static > T min(Collection coll)
public static T min(Collection coll,Comparator comp) 前者采用Collection内含自然比较法，后者采用Comparator进行比较。
6. indexOfSubList
查找subList在list中首次出现位置的索引
public static int indexOfSubList(List source,List target)demo:
public class Practice {
public static void main(String[] args){
List list = Arrays.asList("one two three four five six siven".split(" "));
System.out.println(list);
List subList = Arrays.asList("three four five six".split(" "));
System.out.println(Collections.indexOfSubList(list, subList));
}
}结果：
[one, two, three, four, five, six, siven]
27. lastIndexOfSubList
使用与上例方法的使用相同。
8. replaceAll
替换批定元素为某元素,若要替换的值存在刚返回true,反之返回false
public static boolean replaceAll(List list,T oldVal,T newVal) demo：
public class Practice {
public static void main(String[] args){
List list = Arrays.asList("one two three four five six siven".split(" "));
System.out.println(list);
List subList = Arrays.asList("three four five six".split(" "));
System.out.println(Collections.replaceAll(list, "siven", "siven eight"));
System.out.println(list);
}
}
运行结果为：
[one, two, three, four, five, six, siven]
true
[one, two, three, four, five, six, siven eight]
9. reverse()
反转集合中元素的顺序
public static void reverse(List list)demo：
public class Practice {
public static void main(String[] args){
List list = Arrays.asList("one two three four five six siven".split(" "));
System.out.println(list);
Collections.reverse(list);
System.out.println(list);
}
}
运行结果为：
[one, two, three, four, five, six, siven]
[siven, six, five, four, three, two, one]10. rotate
集合中的元素向后移m个位置，在后面被遮盖的元素循环到前面来
public static void rotate(List list, int distance)demo：
public class Practice {
public static void main(String[] args){
List list = Arrays.asList("one two three four five six siven".split(" "));
System.out.println(list);
Collections.rotate(list, 1);
System.out.println(list);
}
}
运行结果为：
[one, two, three, four, five, six, siven]
[siven, one, two, three, four, five, six]11. copy
将集合n中的元素全部复制到m中,并且覆盖相应索引的元素
1 public static void copy(List dest, List src) demo：
public class Practice {
public static void main(String[] args){
List m = Arrays.asList("one two three four five six siven".split(" "));
System.out.println(m);
List n = Arrays.asList("我 是 复制过来的哈".split(" "));
System.out.println(n);
Collections.copy(m,n);
System.out.println(m);
}
}
运行结果为：
[one, two, three, four, five, six, siven]
[one, two, four, three, five, six, siven]12. swap
交换集合中指定元素索引的位置
public static void swap(List list,int i,int j)demo：
public class Practice {
public static void main(String[] args){
List m = Arrays.asList("one two three four five six siven".split(" "));
System.out.println(m);
Collections.swap(m, 2, 3);
System.out.println(m);
}
}
运行结果为：
[one, two, three, four, five, six, siven]
[one, two, four, three, five, six, siven]13. fill
用对象o替换集合list中的所有元素
public static void fill(List list, T obj) demo：
public class Practice {
public static void main(String[] args){
List m = Arrays.asList("one two three four five six siven".split(" "));
System.out.println(m);
Collections.fill(m, "haha52T25xixi");
System.out.println(m);
}
}
运行结果为：
[one, two, three, four, five, six, siven]
[haha52T25xixi, haha52T25xixi, haha52T25xixi, haha52T25xixi, haha52T25xixi, haha52T25xixi, haha52T25xixi]14. nCopies
返回大小为n的List，List不可改变,其中的所有引用都指向o
public static List nCopies(int n, T o) demo：
public class Practice {
public static void main(String[] args){
System.out.println(Collections.nCopies(5, "haha"));
}
}
运行结果为：
[haha, haha, haha, haha, haha]