[Java进阶]学习笔记15：Collections集合工具类的方法

java.util.Collections是集合工具类，用来对集合进行操作

部分方法如下：

public static boolean addAll(Collection,T…elements); //往集合中添加一些元素
public static void shuffle(List<?> list) //打乱集合顺序
public static void sort(List list); //将集合中元素按照默认规则排序(默认是升序)
public static void sort(List List,Comparator<? super T>) //将集合中元素按照指定规则排序

1.addAll方法和shuffle方法

public static boolean addAll(Collection,T…elements); //往集合中添加一些元素
public static void shuffle(List<?> list) //打乱集合顺序

public class Demo01Collections {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
//        list.add("a");
//        list.add("b");
//        list.add("c");
//        list.add("d");
//        list.add("e");

        //public static <T> boolean addAll(Collection<T>,T...elements); //往集合中添加一些元素
        Collections.addAll(list,"a","b","c","d","e");
        System.out.println(list);

        //public static void shuffle(List<?> list) //打乱集合顺序
        Collections.shuffle(list);
        System.out.println(list);

    }
}

2.sort(List<T> list)方法

public static void sort(List list); //将集合中元素按照默认规则排序(默认是升序)

注意事项：
sort方法使用前提：
被排序的集合里边存储的元素，
必须实现Comparable接口,
重写接口中的方法CompareTo定义排序的规则

Comparable接口的排序规则：
自己(this) - 参数 ； 升序
参数 - 自己(this) ； 降序

Person.java

package demo15.Collections;


public class Person implements Comparable<Person>{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //重写排序的规则
    @Override
    public int compareTo(Person o) {
        //return 0;//认为元素时相同的
        //自定义比较的规则，比较两个人的年龄(this,参数Person)
        return this.getAge() - o.getAge(); //年龄升序排序
    }
}

Demo

public class Demo02Collections {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(2);
        System.out.println(list01);

        //public static <T> void sort(List<T> list); //将集合中元素按照默认规则排序
        Collections.sort(list01);
        System.out.println(list01);//默认是升序

        //自定义类型的排序，需要重写Compare
        ArrayList<Person> list02 = new ArrayList<>();
        list02.add(new Person("Clearlove",18));
        list02.add(new Person("Uzi",17));
        list02.add(new Person("Meiko",19));
        System.out.println(list02);

        Collections.sort(list02);
        System.out.println(list02);
    }
}

可以看到，Person类实现了Comparable接口并重写了CompareTo方法！
只有这样，自定义类型的集合才能使用sort方法！

运行结果：

成功将Person对象按照年龄升序排序

3.sort(List<T> List,Comparator<? super T>)方法

public static void sort(List List,Comparator<? super T>) //将集合中元素按照指定规则排序

Comparator 和 Comparable的区别
Comparable：自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较的规则CompareTo方法

Comparator：相当于找一个第三方的裁判，比较两个

Comparator的排序规则：
o1-o2; 升序
o2-o1; 降序

Student.java

package demo15.Collections;


public class Student{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}

Demo

public class Demo03Collections {

    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(2);
        System.out.println(list01);

        Collections.sort(list01, new Comparator<Integer>(){
            //重写比较的规则
            @Override
            public int compare(Integer o1,Integer o2)   {
                return o1-o2; //升序
            }
        });

        System.out.println(list01);


        //自定义类型排序
        ArrayList<Student> list02 = new ArrayList<>();
        list02.add(new Student("Faker",18));
        list02.add(new Student("Clearlove",18));
        list02.add(new Student("Uzi",17));
        list02.add(new Student("Meiko",19));
        System.out.println(list02);

        Collections.sort(list02,new Comparator<Student>(){
            //重写排序的规则
            @Override
            public int compare(Student o1,Student o2){
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println(list02);

        Collections.sort(list02,new Comparator<Student>(){
            //重写排序的规则
            @Override
            public int compare(Student o1,Student o2){
                int result =  o1.getAge() - o2.getAge();//升序
                //如果两人年龄相同，则按照姓名首字母排序
                if(result == 0){
                    result = o1.getName().charAt(0) - o2.getName().charAt(0);
                }
                return result;
            }
        });
        System.out.println(list02);

        }
}

这个sort方法需要传递两个参数，一个是需要排序的集合，另一个是Comparator对象，通过重写Comparator类的compare方法，来定义不同的比较规则。

我们可以看到，代码中为了实现Student对象的排序，先后使用匿名类和匿名对象重写了两次compare方法，
第一次重写，规则是：只按照年龄的大小升序排序！
第二次重写，规则是：按照年龄的大小升序排序，如果其中两者的年龄相等，则按照两者的姓名首字母大小排序！

运行结果：