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)方法。代码很简洁，就两个私有属性： 

Java代码  

1. 
   /** 
2. 
    * 员工实体 
3. 
    * @author Sam 
4. 
    * 
5. 
    */  
6. 
   public class Employee implements Comparable<Employee> {  
7. 
         
8. 
       private int id;// 员工编号  
9. 
       private double salary;// 员工薪资  
10. 
          
11. 
        public int getId() {  
12. 
            return id;  
13. 
        }  
14. 
      
15. 
        public void setId(int id) {  
16. 
            this.id = id;  
17. 
        }  
18. 
      
19. 
        public double getSalary() {  
20. 
            return salary;  
21. 
        }  
22. 
      
23. 
        public void setSalary(double salary) {  
24. 
            this.salary = salary;  
25. 
        }  
26. 
          
27. 
        public Employee(int id, double salary) {  
28. 
            super();  
29. 
            this.id = id;  
30. 
            this.salary = salary;  
31. 
        }  
32. 
          
33. 
        // 为了输出方便，重写toString方法  
34. 
        @Override  
35. 
        public String toString() {  
36. 
            // 简单输出信息  
37. 
            return “id:”+ id + “,salary=” + salary;  
38. 
        }  
39. 
      
40. 
        // 比较此对象与指定对象的顺序  
41. 
        @Override  
42. 
        public int compareTo(Employee o) {  
43. 
            // 比较员工编号，如果此对象的编号大于、等于、小于指定对象，则返回1、0、-1  
44. 
            int result = this.id > o.id ? 1 : (this.id == o.id ? 0 : -1);  
45. 
            // 如果编号相等，则比较薪资  
46. 
            if (result == 0) {  
47. 
                // 比较员工薪资，如果此对象的薪资大于、等于、小于指定对象，则返回1、0、-1  
48. 
                result = this.salary > o.salary ? 1 : (this.salary == o.salary ? 0 : -1);  
49. 
            }  
50. 
            return result;  
51. 
        }  
52. 
      
53. 
    }  

2、主类（测试类）：主类内部定义了一个员工比较器 

Java代码  

1. 
   /** 
2. 
    * 测试两种比较器 
3. 
    * @author Sam 
4. 
    * 
5. 
    */  
6. 
   public class TestEmployeeCompare {  
7. 
     
8. 
       /** 
9. 
        * @param args 
10. 
         */  
11. 
        public static void main(String[] args) {  
12. 
              
13. 
            List<Employee> employees = new ArrayList<Employee>();  
14. 
            employees.add(new Employee(2, 5000));  
15. 
            employees.add(new Employee(1, 4500));  
16. 
            employees.add(new Employee(4, 3500));  
17. 
            employees.add(new Employee(5, 3000));  
18. 
            employees.add(new Employee(4, 4000));  
19. 
            // 内部比较器：要排序的对象要求实现了Comparable接口  
20. 
            Collections.sort(employees);  
21. 
            System.out.println(”通过内部比较器实现：”);  
22. 
            System.out.println(employees);  
23. 
              
24. 
            List<Employee> employees2 = new ArrayList<Employee>();  
25. 
            employees2.add(new Employee(2, 5000));  
26. 
            employees2.add(new Employee(1, 4500));  
27. 
            employees2.add(new Employee(4, 3500));  
28. 
            employees2.add(new Employee(5, 3000));  
29. 
            employees2.add(new Employee(4, 4000));  
30. 
            // 外部比较器：自定义类实现Comparator接口  
31. 
            Collections.sort(employees2, new EmployeeComparable());  
32. 
            System.out.println(”通过外部比较器实现：”);  
33. 
            System.out.println(employees2);  
34. 
        }  
35. 
      
36. 
    }  
37. 
      
38. 
    /** 
39. 
     * 自定义员工比较器 
40. 
     * 
41. 
     */  
42. 
    class EmployeeComparable implements Comparator<Employee> {  
43. 
      
44. 
        @Override  
45. 
        public int compare(Employee o1, Employee o2) {  
46. 
            // 比较员工编号，如果此对象的编号大于、等于、小于指定对象，则返回1、0、-1  
47. 
            int result = o1.getId() > o2.getId() ? 1 : (o1.getId() == o2.getId() ? 0 : -1);  
48. 
            // 如果编号相等，则比较薪资  
49. 
            if (result == 0) {  
50. 
                // 比较员工薪资，如果此对象的薪资大于、等于、小于指定对象，则返回1、0、-1  
51. 
                result = o1.getSalary() > o2.getSalary() ? 1 : (o1.getSalary() == o2.getSalary() ? 0 : -1);  
52. 
            }  
53. 
            return result;  
54. 
        }  
55. 
          
56. 
    }  

程序输出结果： 
为了让大家较全，我把结果拷贝下来，如下： 

通过内部比较器实现： 
[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)方法，根据自己的需求定义比较规则。使用外部比较器这种方式比较灵活，例如现在需求是按照员工编号和薪资进行排序，以后可能按照姓名进行排序，这时只要再写一个按照姓名规则比较的比较器就可以了。