我們知道Object類有一個equals方法，用於比較兩個對象是否相等

我們只要在自定義類中重寫了equals方法（若不重寫就是比較兩個實例的地址，相當於==）就可以用來比較該類的兩個實例是否相等

問題1：我們如何比較類的兩個實例的大小呢？

問題2：我們知道集合中的list和數組中的元素都是有序的，那麽當這些元素為自定義類的實例時，那如何進行排序呢？

我們知道集合有Collections.sort()，數組 有Arrays.sort()進行排序，但是前提是這些元素是可排序的

對於問題1，如果只是單純的比較兩個實例的大小，那麽只要在類中寫一個比較的方法就行了

但如果要進行排序呢，只在類中寫一個比較的方法就不行了。

要對以對象為元素的list或者數組進行排序，有兩種方法

一種是對象的類實現Comparable接口

另一種是類本身不實現Comparable接口，而是另外寫一個類來實現Comparator接口，這個類就是一個比較器，可用於比較兩個對象的大小

實現了Comparable接口的類和實現了Comparator的比較器類都可以比較兩個實例的大小，進而進行排序

關於Comparable和Comparator接口，拷貝於以下

https://www.cnblogs.com/xujian2014/p/5215082.html

一、Comparable簡介

　　Comparable是排序接口。若一個類實現了Comparable接口，就意味著該類支持排序。實現了Comparable接口的類的對象的列表或數組可以通過Collections.sort或Arrays.sort進行自動排序。

　　此外，實現此接口的對象可以用作有序映射中的鍵或有序集合中的集合，無需指定比較器。該接口定義如下：

package java.lang;
import java.util.*;
public interface Comparable<T> 
{
    public int compareTo(T o);
}

　　T表示可以與此對象進行比較的那些對象的類型。

　　此接口只有一個方法compare，比較此對象與指定對象的順序，如果該對象小於、等於或大於指定對象，則分別返回負整數、零或正整數。

　　現在我們假設一個Person類，代碼如下：

public class Person
{
    String name;
    int age;
    public Person(String name, int age)
    {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
 
　　public int getAge()
    {
        return age;
    }
}

　　現在有兩個Person類的對象，我們如何來比較二者的大小呢？我們可以通過讓Person實現Comparable接口：

public class Person implements Comparable<Person>
{
    String name;
    int age;
    public Person(String name, int age)
    {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    @Override
    public int compareTo(Person p)
    {
        return this.age-p.getAge();
    }
    public static void main(String[] args)
    {
        Person[] people=new Person[]{new Person("xujian", 20),new Person("xiewei", 10)};
        System.out.println("排序前");
        for (Person person : people)
        {
            System.out.print(person.getName()+":"+person.getAge());
        }
        Arrays.sort(people);    //Person類本身實現了Comparable接口，可排序，不需要制定比較器
        System.out.println("\n排序後");
        for (Person person : people)
        {
            System.out.print(person.getName()+":"+person.getAge());
        }
    }
}

　　程序執行結果為：

二、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接口，從而構造一個“比較器"。

public class PersonCompartor implements Comparator<Person>
{
    @Override
    public int compare(Person o1, Person o2)
    {
        return o1.getAge()-o2.getAge();
    }
}

　　現在我們就可以利用這個比較器來對其進行排序：

public class Person
{
    String name;
    int age;
    public Person(String name, int age)
    {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public static void main(String[] args)
    {
        Person[] people=new Person[]{new Person("xujian", 20),new Person("xiewei", 10)};
        System.out.println("排序前");
        for (Person person : people)
        {
            System.out.print(person.getName()+":"+person.getAge());
        }
        Arrays.sort(people,new PersonCompartor());    //Person類未實現Comparable接口，本身不可排序，需要指定比較器
        System.out.println("\n排序後");
        for (Person person : people)
        {
            System.out.print(person.getName()+":"+person.getAge());
        }
    }
}

　　程序運行結果為：

三、Comparable和Comparator區別比較

　　Comparable是排序接口，若一個類實現了Comparable接口，就意味著“該類支持排序”。

Comparator是比較器，我們若需要控制某個類的次序，可以建立一個“該類的比較器”來進行排序。

　　Comparable相當於“內部比較器”，而Comparator相當於“外部比較器”。

　　兩種方法各有優劣， 用Comparable 簡單， 只要實現Comparable 接口的對象直接就成為一個可以比較的對象，但是需要修改源代碼。

用Comparator 的好處是不需要修改源代碼， 而是另外實現一個比較器， 當某個自定義的對象需要作比較的時候，把比較器和對象一起傳遞過去就可以比大小了， 並且在Comparator 裏面用戶可以自己實現復雜的可以通用的邏輯，使其可以匹配一些比較簡單的對象，那樣就可以節省很多重復勞動了。

比如你引入了別人寫的一個類，需要對這個類的實例進行比較或者排序，若要使用實現Comparable接口的方法，則你需要對引入的類進行源代碼的修改

而如果使用實現Comparator接口的方式，則不需要對引入的類進行修改，只需要重新寫一個引入類的比較器類就可以了

例如，幾個不同的類有相同的比較方式，可以創建一個泛型的比較器，來實現通用的邏輯

class CompareObj<T> implements Comparator<T>{
    public int compare(T o1, T o2) {
        return o1.getAge() - o2.getAge();
    }
}

Arrays.sort(people, new CompareObj<Person>());

java學習--自定義類的實例的大小比較和排序