基本概念
    java中，对数组对象和集合对象排序，有两种实现方法
    即： （1）对象实现Comparable接口。
    （2）定义比较器，实现Comparator接口。
    一、Comparable接口：
    1、此接口对每个实现它的类的对象施加了一个总排序，这个排序成为类的自然排序，这个类的CompareTo方法被称为自然比较方法。
    2、若一个类实现了Comparable接口，就意味着该类支持排序。实现了该接口的类的数组对象或集合对就可以使用Arrays.sort或Collections.sort方法进行排序。

    1. /**
    2.  * 实体类
    3.  */
    4. public class Person implements Comparable<Person>{
    5.     String name;
    6.     int age;
    7.     // 方式一
    8.     @Override
    9.     public int compareTo(Student o) {
    10.         if (this.age>o.age)return 1;
    11.         else if (this.age<o.age)return -1;
    12.         return 0;
    13.     }
    14.     // 方式二
    15.     @Override
    16.     public int compareTo(Student o) {
    17.           return this.age - o.age;
    18.     }
    19. }
    20. public class ComparableTest {
    21.     public static void main(String[] args) {
    22.         Student[] stu=new Student[]{
    23.           new Student("魏宇明",18),
    24.           new Student("蔡林虎",21),
    25.           new Student("袁新槐",19)
    26.         };
    27.         System.out.println("对象数组排序前："+Arrays.toString(stu));
    28.         Arrays.sort(stu);
    29.         System.out.println("对象数组排序后："+Arrays.toString(stu));
    30.         List<Student> list=new ArrayList<>();
    31.         list.add(new Student("魏宇明",18));
    32.         list.add(new Student("蔡林虎",21));
    33.         list.add(new Student("袁新槐",19));
    34.         System.out.println("对象集合排序前："+list);
    35.         Collections.sort(list);
    36.         System.out.println("对象集合排序后："+list);
    37.     }
    38. }

    二、Comparator接口：
    应用场景
    1、我们若需要对一个对象进行排序，而该类没有实现Comparable接口。
    2、如果引用的为第三方jar包，这时候，没办法改变类本身，可是使用这种方式。
    介绍
    1、Comparator是一个专用的比较器，当这个对象不支持自比较或者比较函数不能满足要求时，可些一个比较器来完成两个对象之间的排序问题。
    2、Comparator体现了一种策略模式，就是不改变对象自身，而用一个策略对象来改变它的行为。

    1. /**
    2.  * 实体类
    3.  */
    4. public class Person{
    5.     String name;
    6.     int age;
    7. }
    8. /**
    9.  * 单独实现类(通过年龄进行排序)
    10.  */
    11. public class PersonComparatorByAge implements Comparator<Person> {
    12.     @Override
    13.     public int compare(Person o1, Person o2) {
    14.         return o1.getAge()-o2.getAge();
    15.     }
    16. }
    17. /**
    18.  * 测试类
    19.  */
    20. public class ComparatorTest{
    21.     public static void main(String[] args){
    22.         List<Person> list=new ArrayList<>();
    23.         list.add(new Person("魏宇明",18));
    24.         list.add(new Person("蔡林虎",21));
    25.         list.add(new Person("袁新槐",19));
    26.         list.add(new Person("马鱼洪",20));
    27.         System.out.println("对象集合排序前："+list);
    28.         // 方式一(调用定义好的实现类)
    29.         Collections.sort(list,new PersonComparatorByAge());
    30.         // 方式二(使用匿名类代替单独的类)
    31.         list.sort(new Comparator<Person>(){
    32.             @Override
    33.             public int compare(Person o1, Person o2) {
    34.                 return o1.getAge()-o2.getAge();
    35.             }
    36.         });
    37.         System.out.println("对象集合排序后："+list);
    38.     }
    39. }

    三、总结
    Comparable和Comparator区别
    1、Comparable是内部比较器Comparator是外部比较器
    2、Comparable是排序接口，若一个类实现了Comparable接口，该类就支持对象排序；Comparator是比较器，需要控制某类的次序，可以建立一个该类的比较器进行排序。