Comparator和Comparable的区别

一、Comparable:是一个排序接口。
里面有一个compareTo(T o)方法 若一个类实现了Comparable接口中的compareTo(T o);方法，就意味着该类支持排序。实现了Comparable接口的类的对象的容器或数组可以通过Collections.sort或Arrays.sort进行自动排序。
Comparable原码：

public interface Comparable<T> {
public int compareTo(T o);
}

  此接口只有一个方法compare，比较此对象与指定对象的顺序，如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。<br />     现在我们有一个person类实现Comparable接口

public class Person implements Comparable<Person>{
    String name;
    int age;
    public Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
      public int getAge()
    {
        return age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Person o) {
                //o.age-age//从大到小排序
        return age-o.age;//从小到大排序
    }
}

    则我们在集合或数组中对person对象进行排序

public class PersonDemo {
    public static void main(String[] args) {
        //集合的使用
        List<Person> arrayList = new ArrayList<>();
        Person p1=new Person("cccc",18);
        Person p2=new Person("dddd",14);
        arrayList.addAll(Arrays.asList(p1,p2));
        System.out.println("对集合排序前："+arrayList);
        //对集合排序
        Collections.sort(arrayList);
        System.out.println("对集合排序后："+arrayList);
        //数组的使用
        System.out.println("==================数组的使用===============");
        Person[]people={p1,p2};
        System.out.println("排序前:");
        for (Person person : people) {
            System.out.print(person);
        }
        System.out.println();
        Arrays.sort(people);
        System.out.println("排序后:");
        for (Person person : people) {
            System.out.print(person);
        }
    }
}
Output:
对集合排序前：[Person{name='cccc', age=18}, Person{name='dddd', age=14}]
对集合排序后：[Person{name='dddd', age=14}, Person{name='cccc', age=18}]
==================数组的使用===============
排序前:
Person{name='cccc', age=18}Person{name='dddd', age=14}
排序后:
Person{name='dddd', age=14}Person{name='cccc', age=18}
Process finished with exit code 0

二、Comparator：
　Comparator是比较接口，我们如果需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)，那么我们就可以建立一个“该类的比较器”来进行排序，这个“比较器”只需要实现Comparator接口即可。也就是说，我们可以通过实现Comparator来新建一个比较器，然后通过这个比较器对类进行排序。该接口定义如下：

package java.util;
public interface Comparator<T>
 {
    int compare(T o1, T o2);
    boolean equals(Object obj);
 }

注意：
1、若一个类要实现Comparator接口：它一定要实现compare(T o1, T o2) 函数，但可以不实现 equals(Object obj) 函数。
　　　2、int compare(T o1, T o2) 是“比较o1和o2的大小”。返回“负数”，意味着“o1比o2小”；返回“零”，意味着“o1等于o2”；返回“正数”，意味着“o1大于o2”。
如果上面列子中Person没有实现comparable接口，那此时我们可以去新建一个类型让其实现comparator接口，从而自己创建一个“比较器”。

import java.util.Comparator;
public class PersonCompartor implements Comparator<Person> {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.age-o2.age;//从小到大排序
               //o2.age-o1.age//从大到小排序
    }
}

package com.Comparator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class PersonDemo {
    public static void main(String[] args) {
        List<Person> arrayList = new ArrayList<>();
       Person p1=new Person("cccc",18);
       Person p2=new Person("dddd",14);
       arrayList.addAll(Arrays.asList(p1,p2));
       Collections.sort(arrayList,new PersonCompartor());
       System.out.println(arrayList);
        System.out.println("==================数组的使用===============");
       Person[]people={p1,p2};
        System.out.println("排序前:");
        for (Person person : people) {
            System.out.print(person);
        }
        System.out.println();
        Arrays.sort(people,new PersonCompartor());
        System.out.println("排序后:");
        for (Person person : people) {
            System.out.print(person);
        }
    }
    }

总结：
如果需要对一个对象进行排序，这个对象是可以修改的，那么我们可以让这个对象之间去实现comparable接口。但如果该对象是不可变的，我们就需要去创建一个新类实现Comparator接口。让这个类充当比较器。来去比较目标对象。