Java的Comparable与Comparator接口详解

对集合或数组进行排序有两种方法：

1.集合中的对象所属的类实现了java.lang.Comparable 接口，然后调用Collections.sort()或者Arrays.sort()
2.实现java.lang.Comparator接口，把这个实现接口的类作为参数传递给上述的sort()方法。

先看Comparable<T>

java.lang 
Interface Comparable<T>

属于Java集合框架下的一个接口。它只有一个方法 int compareTo(T o) 用于提供排序所需要的比较逻辑。

实现这个接口的类，其对象都可以通过调用Collections.sort()或者Arrays.sort()进行排序，根据compareTo的逻辑升序排列。

 1 /*
 2  * 方便起见省略getter&setting，主要演示接口作用。 
 3         这种实现并不严谨，因为没有覆盖 equals() 和 hashCode()，原因后面描述。       
 4         这个接口的作用：如果数组或者集合中的（类）元素实现了该接口的话 ,       
 5         可以调用 Collections.sort 和 Arrays.sort 排序，或应用于有序集合 TreeSet 和 TreeMap 中。 
 6  * 
 7  */
 8 public class Person implements Comparable<Person> {
 9     public int id;
10     public String name;
11     
12     public Person(int id,String name){
13         this.id=id;
14         this.name = name;
15     }
16 
17     public String toString(){
18         return "Person: "+id+" , "+name;
19     }
20     
21     /*
22      * 实现 Comparable 接口的抽象方法，定义排序规则
23      *  this < obj 返回负
24         this = obj 返回 0
25         this > obj 返回正
26      * @see java.lang.Comparable#compareTo(java.lang.Object)
27      */
28     @Override
29     public int compareTo(Person o) {
30         // TODO Auto-generated method stub
31         return this.id - o.id;
32     }    
33 }

测试类

 1 public class TestComparable {
 2 
 3     private static Person p1 = new Person(301,"a");
 4     private static Person p2 = new Person(100,"e");
 5     private static Person p3 = new Person(101,"d");
 6     private static Person p4 = new Person(143,"f");
 7     private static Person p5 = new Person(139,"b");
 8     private static Person p6 = new Person(113,"c");
 9     
10     public static void main(String[] args) {
11         // TODO Auto-generated method stub
12         List<Person> persons = new ArrayList<Person>();
13         persons.add(p1);
14         persons.add(p2);
15         persons.add(p3);
16         persons.add(p4);
17         persons.add(p5);
18         persons.add(p6);
19         
20         Collections.sort(persons);
21         System.out.println("--------------Result 1-----------------");
22         for(Person p : persons){
23             System.out.println(p.toString());
24         }
25         
26         TreeSet<Person> personSet = new TreeSet<Person>(); 
27         personSet.add(p1);
28         personSet.add(p2);
29         personSet.add(p3);
30         personSet.add(p4);
31         personSet.add(p5);
32         personSet.add(p6);
33         
34         System.out.println("---------------Result 2----------------");
35         for(Person p : personSet){
36             System.out.println(p.toString());
37         }
38         
39         Collections.sort(persons, new PersonComparator()); 
40         System.out.println("---------------Result 3----------------");
41         for(Person p :persons){
42             System.out.println(p.toString());
43         }
44         
45     }
46 
47 }

输出：

--------------Result 1-----------------
Person: 100 , e
Person: 101 , d
Person: 113 , c
Person: 139 , b
Person: 143 , f
Person: 301 , a
---------------Result 2----------------
Person: 100 , e
Person: 101 , d
Person: 113 , c
Person: 139 , b
Person: 143 , f
Person: 301 , a
---------------Result 3----------------
Person: 301 , a
Person: 139 , b
Person: 113 , c
Person: 101 , d
Person: 100 , e
Person: 143 , f

Result 1是调用了Collections.sort()，而Result 2则是集合本身有序(Sorted Set/Sorted Map)，例如TreeMap和TreeSet。使用非常简单。

值得注意的有以下两点：

1. 注意BigDecimal。所有实现 Comparable 的 Java 核心类都具有与 equals 一致的自然排序。java.math.BigDecimal 是个例外，它的自然排序将值相等但精确度不同的 BigDecimal 对象（比如 4.0 和 4.00）视为相等。

 1 public class Salary implements Comparable<Salary> {
 2     
 3     private BigDecimal money;
 4     
 5     public Salary(BigDecimal money){
 6         this.money = money;
 7     }
 8     
 9     public String toString(){
10         return this.money.toString();
11     }
12 
13     @Override
14     public int compareTo(Salary o) {
15 
16         return this.money.compareTo(o.money);
17         //Do NOT use: return (this.money.subtract(o.money)).intValue();
18     }
19 
20     
21     public static void main(String[] args) {
22         // TODO Auto-generated method stub
23         TreeSet<Salary> salarySet = new TreeSet<Salary>();
24         salarySet.add(new Salary(new BigDecimal(100.23)));
25         salarySet.add(new Salary(new BigDecimal(100.01)));
26         salarySet.add(new Salary(new BigDecimal(100.21009)));
27         salarySet.add(new Salary(new BigDecimal(100.2300)));
28         
29         for(Salary s : salarySet){
30             System.out.println(s.toString());
31         }
32     }
33 }

2. 保证类的自然顺序与equals一致。在重写 compareTo() 方法以定制比较逻辑时，需要确保其与等价性判断方法 equals() 保持一致，即 e1.equals(e2) 和e1.compareTo(e2)==0 具有相同的值，这样的话我们就称自然顺序就和 equals 一致。

在使用自然排序与 equals 不一致的元素（或键）时，没有显式比较器的有序集合（和有序映射表）行为表现“怪异”。特别是，这样的有序集合（或有序映射表）违背了根据 equals 方法定义的集合（或映射表）的常规协定。

 1 public class PersonWithQQ implements Comparable<PersonWithQQ> {
 2     
 3     private int id;
 4     private int qq;
 5     
 6     public PersonWithQQ(int id,int qq){
 7         this.id = id;
 8         this.qq = qq;
 9     }
10     
11     //与compareTo的方法不一致，也就是与自然顺序不一致。
12     @Override 
13     public boolean equals(Object o){          //......1
14         if(!(o instanceof PersonWithQQ)) 
15             return false;
16         PersonWithQQ person = (PersonWithQQ)o;
17         return this.id==person.id;
18     }
19     
20     //compareTo方法得到的顺序，称为自然顺序。
21     @Override
22     public int compareTo(PersonWithQQ obj) {  //......2
23         // TODO Auto-generated method stub
24         return this.qq-obj.qq;
25     }
26 
27     public String toString(){
28         return id+","+qq;
29     }
30 
31     public static void main(String[] args) {
32         
33         TreeSet<PersonWithQQ> personSet = new TreeSet<PersonWithQQ>(); //......3
34         
35         personSet.add(new PersonWithQQ(101,301)); //...p1
36         personSet.add(new PersonWithQQ(101,302)); //...p2 
37         personSet.add(new PersonWithQQ(102,302)); //...p3
38         
39         for(PersonWithQQ p : personSet){
40             System.out.println(p.toString());
41         }
42         
43     }
44 }

可以看到，PersonWithQQ这个类equals比较的是id，而compareTo比较的是qq号码，违反了e1.equals(e2) 和e1.compareTo(e2)==0 具有相同的布尔值。这样，没有显式比较器的有序集合行为会“奇怪”。请看输出：

101,301
101,302

事实上本来按照equals的方法，p1和p2应该是指同一个的对象，现在却加入了不能允许有重复值的set集合里面。

对于p2和p3，我们有(!p2.equals(p3) && p2.compareTo(p3) == 0)，p3无法加入到set集合里，set集合里只有两个对象。这是因为在sorted set的角度，p2和p3是相等的，而却跟equals的相等方法矛盾。这就是自然顺序与equals不一致。

上述的Person类，其实也是不严谨的，因为没有覆盖equals方法来表达判断对象相等的标准是id相等。

虽然是这种情况只发生在没有显式比较器有序集合中(sorted set/map)，但是，在实现Comparable接口时，还是建议覆盖equals方法和hashCode方法，保证与自然顺序（CompareTo方法）一致，防止在有序集合中使用出问题。

 

解决方法很简单，要不就重新覆盖equals或compareTo的其中一个方法，使其与另一个方法一致。要不就显式使用比较器。

上述PersonWithQQ类中第33行代码替换为：

 1 //显式使用Comparator
 2         TreeSet<PersonWithQQ> personSet = new TreeSet<PersonWithQQ>(new Comparator<PersonWithQQ>() {
 3 
 4             @Override
 5             public int compare(PersonWithQQ o1, PersonWithQQ o2) {
 6                 // TODO Auto-generated method stub
 7                 
 8                 return o1.id-o2.id;
 9             }
10             
11         });

本质上来说，使用比较器也是为了使自然顺序与equals一致，这样最为稳妥。

再来看Comparator<T>

java.util 
Interface Comparator<T>

简单来说，Comparator是策略模式的一种实现，体现了将类和排序算法相分离的原则。

1 public class PersonComparator implements Comparator<Person> {
2 
3     @Override
4     public int compare(Person p0, Person p1) {
5         // TODO Auto-generated method stub
6         
7         return p0.name.compareTo(p1.name);
8     }
9 }

这是Person类的另一种排序方法，根据名字字母排序，因此输出不再根据id排列：

---------------Result 3----------------
Person: 301 , a
Person: 139 , b
Person: 113 , c
Person: 101 , d
Person: 100 , e
Person: 143 , f

而这个Comparator可以作为参数传递给sort方法，提供各种不同的排序方法。

在很多时候，对于需要排序的原始类，例如Person类、PersonWithQQ类，不一定能修改代码使其实现Comparable接口；这时候Comparator就可以发挥作用了。

参考：

http://docs.oracle.com/javase/6/docs/api/java/lang/Comparable.html

http://docs.oracle.com/javase/6/docs/api/java/util/Comparator.html

http://blog.csdn.net/itm_hadf/article/details/7432782

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/techyc/p/2679718.html