Collections工具类常用方法，Comparator和Comparable比较器

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

常用方法：

public static <T> boolean addAll(Collection<T> c, T... elements) 往集合中添加一些元素

ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,23,1421,1412,412,547);
System.out.println(list);              //输出:[23,1421,1412,412,547]

public static void shuffle(List<?> list) 打乱集合元素顺序

ArrayList<Integer> list = new ArrayList<>();
ArrayList<Integer> list1 = new ArrayList<>();
Collections.addAll(list,23,1421,1412,412,547);
Collections.shuffle(list);
System.out.println(list);                //输出:[1412, 23, 1421, 412, 547]

注意：Collections.shuffle()方法每次输出的结果都是不一样的

public static <T> void sort(List<T> list) 将集合中元素按照默认规则排序。

ArrayList<Integer> list = new ArrayList<>();
ArrayList<Integer> list1 = new ArrayList<>();
Collections.addAll(list,23,1421,1412,412,547);
Collections.sort(list);
System.out.println(list);                //输出:[23, 412, 547, 1412, 1421]

注意：其他数据类型使用Collections.sort()方法时，java内部有对各种数据类型进行排序(Integer是按升序进行排序)

Comparator自定义比较器：

public static <T> void sort(List<T> list,Comparator<? super T> c) 使用自定义比较器对集合中元素进行排序

1.新建一个自定义的类实现Comparator<T>，且重写Comparator<T> 的抽象方法public int compare(T o1,T o2)

public class MyComparator implements Comparator<Integer>{
     @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;            //return 的值可以根据自己需求随意修改
        }
}

2.调用Collections.sort(List<T> list,Comparator<? super T> c) .方法！

<? super T> 表示的是只能接受此类和他的父类类型的数据

第一个参数List<T> list ：传入要自定义排序的集合名

第二个参数Comparator<? super T> c ：传入刚刚创建好的自定义类对象，注意是对象！

ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,23,1421,1412,412,547);
Collections.sort(list, new MyComparator());            //传入匿名对象new MyComparator()
System.out.println(list);                              //输出:[1421, 1412, 547, 412, 23]

这样就完成了Integer集合的降序排序

比较器根据return后面两个参数相减的正负值来判断前后数值大小，然后判断是否更换位置

所以我们可以改变return后面两个参数的位置来实现升序或者降序排序

同样该方法也可以用来完成字符串长度排序等等

Camparable自定义比较器：

public static <T> void sort(List<T> list,Comparator<? super T> c) 使用自定义比较器对集合中元素进行排序

1.创建一个自定义类实现Comparable<T>，并且重写compareTo()方法

返回值写的就是根据自定义类的成员变量顺序进行排序的依据

两个元素之间是否更换位置根据return返回数值的正负

public class Student implements Comparable<Student>{

    private String name;
    private int age;

    @Override
    public int compareTo(Student o) {                //重写的compareTo()方法
        return this.age - o.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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

2.主方法中，使用public static <T> void sort(List<T> list)

将存有自定义对象的List集合当作参数传入方法体

输出便是按照成员变量age作的排序

Student s1 = new Student("1号学生", 22);
Student s2 = new Student("2号学生", 33);
Student s3 = new Student("3号学生", 18);
Student s4 = new Student("4号学生", 15);
Student s5 = new Student("5号学生", 26);
ArrayList<Student> list = new ArrayList<>();
Collections.addAll(list,s1,s2,s3,s4,s5);
Collections.sort(list);                //使用Collections.sort()对自定义对象进行排序
System.out.println(list);
//最后输出:
//[Student{name='4号学生', age=15}, 
//Student{name='3号学生', age=18},
//Student{name='1号学生', age=22},
//Student{name='5号学生', age=26},
//Student{name='2号学生', age=33}]

注意：

实现Comparable<T>接口的自定义比较器方法，只能用来比较自定义数据类型

基本数据类型的包装类要用这种方法作比较的话

必须到官方定义好的源码中实现Comparable<T>接口，和重写compareTo()方法

这样做显然不可取

对基本数据类型的包装类进行排序时候只能自定义比较器实现Comparator<T>

比较自定义对象时不仅可以使用Comparator<T>方法也可以使用Comparable<T>方法