Java中兩種比較器的實現

先舉例說明： 
例一：如果要對一組數字進行排序，可以寫一個排序算法實現。 
例如： 
1 4 6 5 3 8 
排序後： 
1 3 4 5 6 8 

例二：如果要對字母進行排序，則可以通過26個字母的自然順序進行排序。 
例如： 
a f b e d c 
排序後： 
a b c d e f 

但是工作中，有時不僅僅是這麼簡答的需求。例如要對一個員工進行排序，員工有員工編號，有薪資等。這時就需要用Java中的比較器來實現了。 

Java 中提供了兩種方式來實現比較： 
1、java.util.Comparator<T> 接口聲明瞭： int compare<T o1, T o2> 方法 
  比較用來排序的兩個參數： 
  1）如果o1大於o2，則返回正整數； 
  2）如果o1小於o2，則返回負整數 
  3）如果o1等於o2，則返回零 

2、java.lang.Comparable<T> 接口聲明瞭： int compareTo(T o) 方法 
  比較此對象與執行對象的順序。比較規則同上，即： 
  1）如果此對象大於指定對象，返回正整數 
  2）如果此對象小於指定對象，返回負整數 
  3）如果此對象等於指定對象，返回零 

下面舉個簡單的例子說明。 
需求：對員工進行排序，員工有員工編號和薪資。排序要求： 
1）按照員工的編號id進行排序 
2）如果員工的編號id相等，則按照員工的薪資進行比較 

上代碼： 
1）先定義一個員工實體，員工實體實現了java.lang.Comparable接口，並重寫compareTo(T o)方法。代碼很簡潔，就兩個私有屬性： 

/**
 * 員工實體
 * @author Sam
 *
 */
public class Employee implements Comparable<Employee> {

    private int id;// 員工編號
    private double salary;// 員工薪資

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Employee(int id, double salary) {
        super();
        this.id = id;
        this.salary = salary;
    }

    // 爲了輸出方便，重寫toString方法
    @Override
    public String toString() {
        // 簡單輸出信息
        return "id:"+ id + ",salary=" + salary;
    }

    // 比較此對象與指定對象的順序
    @Override
    public int compareTo(Employee o) {
        // 比較員工編號，如果此對象的編號大於、等於、小於指定對象，則返回1、0、-1
        int result = this.id > o.id ? 1 : (this.id == o.id ? 0 : -1);
        // 如果編號相等，則比較薪資
        if (result == 0) {
            // 比較員工薪資，如果此對象的薪資大於、等於、小於指定對象，則返回1、0、-1
            result = this.salary > o.salary ? 1 : (this.salary == o.salary ? 0 : -1);
        }
        return result;
    }

}

2、主類（測試類）：主類內部定義了一個員工比較器 

/**
 * 測試兩種比較器
 * @author Sam
 *
 */
public class TestEmployeeCompare {

    /**
     * @param args
     */
    public static void main(String[] args) {

        List<Employee> employees = new ArrayList<Employee>();
        employees.add(new Employee(2, 5000));
        employees.add(new Employee(1, 4500));
        employees.add(new Employee(4, 3500));
        employees.add(new Employee(5, 3000));
        employees.add(new Employee(4, 4000));
        // 內部比較器：要排序的對象要求實現了Comparable接口
        Collections.sort(employees);
        System.out.println("通過內部比較器實現：");
        System.out.println(employees);

        List<Employee> employees2 = new ArrayList<Employee>();
        employees2.add(new Employee(2, 5000));
        employees2.add(new Employee(1, 4500));
        employees2.add(new Employee(4, 3500));
        employees2.add(new Employee(5, 3000));
        employees2.add(new Employee(4, 4000));
        // 外部比較器：自定義類實現Comparator接口
        Collections.sort(employees2, new EmployeeComparable());
        System.out.println("通過外部比較器實現：");
        System.out.println(employees2);
    }

}

/**
 * 自定義員工比較器
 *
 */
class EmployeeComparable implements Comparator<Employee> {

    @Override
    public int compare(Employee o1, Employee o2) {
        // 比較員工編號，如果此對象的編號大於、等於、小於指定對象，則返回1、0、-1
        int result = o1.getId() > o2.getId() ? 1 : (o1.getId() == o2.getId() ? 0 : -1);
        // 如果編號相等，則比較薪資
        if (result == 0) {
            // 比較員工薪資，如果此對象的薪資大於、等於、小於指定對象，則返回1、0、-1
            result = o1.getSalary() > o2.getSalary() ? 1 : (o1.getSalary() == o2.getSalary() ? 0 : -1);
        }
        return result;
    }

}

程序輸出結果： 
爲了讓大家較全，我把結果拷貝下來，如下： 

通過內部比較器實現： 
[id:1,salary=4500.0, id:2,salary=5000.0, id:4,salary=3500.0, id:4,salary=4000.0, id:5,salary=3000.0] 
通過外部比較器實現： 
[id:1,salary=4500.0, id:2,salary=5000.0, id:4,salary=3500.0, id:4,salary=4000.0, id:5,salary=3000.0] 

結果分析： 
1）從程序輸出結果中，可以很清晰的看出，兩個比較器均可以實現同樣的需求 
2）id都爲4的員工編號中，按照薪資來進行排序了 

最後，總結一下兩種比較器的區別： 
1）如果使用內部比較器，需要比較的對象必須要實現Comparable接口，並重寫compareTo( 
T o)方法，否則不能直接使用Collections中的sort方法，程序會報錯。因爲程序不知道你要以何種方式來進行比較。 
2）使用外部比較器，需要自己寫一個比較器實現Comparator接口，並實現compare(T o1, T o2)方法，根據自己的需求定義比較規則。使用外部比較器這種方式比較靈活，例如現在需求是按照員工編號和薪資進行排序，以後可能按照姓名進行排序，這時只要再寫一個按照姓名規則比較的比較器就可以了。