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的逻辑升序排列。

/*
 * 方便起见省略getter&setting，主要演示接口作用。 
        这种实现并不严谨，因为没有覆盖 equals() 和 hashCode()，原因后面描述。       
        这个接口的作用：如果数组或者集合中的（类）元素实现了该接口的话 ,       
        可以调用 Collections.sort 和 Arrays.sort 排序，或应用于有序集合 TreeSet 和 TreeMap 中。 
 * 
 */
public class Person implements Comparable<Person> {
    public int id;
    public String name;
    
    public Person(int id,String name){
        this.id=id;
        this.name = name;
    }

    public String toString(){
        return "Person: "+id+" , "+name;
    }
    
    /*
     * 实现 Comparable 接口的抽象方法，定义排序规则
     *  this < obj 返回负
        this = obj 返回 0
        this > obj 返回正
     * @see java.lang.Comparable#compareTo(java.lang.Object)
     */
    @Override
    public int compareTo(Person o) {
        // TODO Auto-generated method stub
        return this.id - o.id;
    }    
}

测试类

public class TestComparable {

    private static Person p1 = new Person(301,"a");
    private static Person p2 = new Person(100,"e");
    private static Person p3 = new Person(101,"d");
    private static Person p4 = new Person(143,"f");
    private static Person p5 = new Person(139,"b");
    private static Person p6 = new Person(113,"c");
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<Person> persons = new ArrayList<Person>();
        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        persons.add(p4);
        persons.add(p5);
        persons.add(p6);
        
        Collections.sort(persons);
        System.out.println("--------------Result 1-----------------");
        for(Person p : persons){
            System.out.println(p.toString());
        }
        
        TreeSet<Person> personSet = new TreeSet<Person>(); 
        personSet.add(p1);
        personSet.add(p2);
        personSet.add(p3);
        personSet.add(p4);
        personSet.add(p5);
        personSet.add(p6);
        
        System.out.println("---------------Result 2----------------");
        for(Person p : personSet){
            System.out.println(p.toString());
        }
        
        Collections.sort(persons, new PersonComparator()); 
        System.out.println("---------------Result 3----------------");
        for(Person p :persons){
            System.out.println(p.toString());
        }
        
    }

}

输出：

--------------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）视为相等。

public class Salary implements Comparable<Salary> {
    
    private BigDecimal money;
    
    public Salary(BigDecimal money){
        this.money = money;
    }
    
    public String toString(){
        return this.money.toString();
    }

    @Override
    public int compareTo(Salary o) {

        return this.money.compareTo(o.money);
        //Do NOT use: return (this.money.subtract(o.money)).intValue();
    }

    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TreeSet<Salary> salarySet = new TreeSet<Salary>();
        salarySet.add(new Salary(new BigDecimal(100.23)));
        salarySet.add(new Salary(new BigDecimal(100.01)));
        salarySet.add(new Salary(new BigDecimal(100.21009)));
        salarySet.add(new Salary(new BigDecimal(100.2300)));
        
        for(Salary s : salarySet){
            System.out.println(s.toString());
        }
    }
}

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

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

public class PersonWithQQ implements Comparable<PersonWithQQ> {
    
    private int id;
    private int qq;
    
    public PersonWithQQ(int id,int qq){
        this.id = id;
        this.qq = qq;
    }
    
    //与compareTo的方法不一致，也就是与自然顺序不一致。
    @Override 
    public boolean equals(Object o){          //......1
        if(!(o instanceof PersonWithQQ)) 
            return false;
        PersonWithQQ person = (PersonWithQQ)o;
        return this.id==person.id;
    }
    
    //compareTo方法得到的顺序，称为自然顺序。
    @Override
    public int compareTo(PersonWithQQ obj) {  //......2
        // TODO Auto-generated method stub
        return this.qq-obj.qq;
    }

    public String toString(){
        return id+","+qq;
    }

    public static void main(String[] args) {
        
        TreeSet<PersonWithQQ> personSet = new TreeSet<PersonWithQQ>(); //......3
        
        personSet.add(new PersonWithQQ(101,301)); //...p1
        personSet.add(new PersonWithQQ(101,302)); //...p2 
        personSet.add(new PersonWithQQ(102,302)); //...p3
        
        for(PersonWithQQ p : personSet){
            System.out.println(p.toString());
        }
        
    }
}

可以看到，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行代码替换为：

//显式使用Comparator
        TreeSet<PersonWithQQ> personSet = new TreeSet<PersonWithQQ>(new Comparator<PersonWithQQ>() {

            @Override
            public int compare(PersonWithQQ o1, PersonWithQQ o2) {
                // TODO Auto-generated method stub
                
                return o1.id-o2.id;
            }
            
        });

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

再来看Comparator<T>

java.util 
Interface Comparator<T>

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

public class PersonComparator implements Comparator<Person> {

    @Override
    public int compare(Person p0, Person p1) {
        // TODO Auto-generated method stub
        
        return p0.name.compareTo(p1.name);
    }
}

这是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