Comparable与Comparator

Compator和Comparable都可以用于集合或者数组的排序。

　　但Comparable是在类内定义比较方法，主要用于对象内部的比较方式，对象需要实现Comparable接口

　　而Compator则是在类外定义比较方法，用作自定义的比较方式

总结：Comparator是比较器，实现Comparable的对象自身可以直接比较 

一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。 

像Arrays和Collections中的排序方法，当不指定Comparator时使用的就是默认排序方式，也就是使用Comparable。指定Comparator时就是使用提供的比较器。 

　　sort(Object[]) 所有的对象都必须实现Comparable接口，它用来确定对象之间的大小关系 

　　sort(Object[], Comparator) 对象不必实现Comparable接口，由Comparator比较器来确定对象之间的大小关系。

Comparable接口位于java.lang包下：

public interface Comparable<T>{
    public int compareTo(T o);//唯一一个方法
}

Comparator接口位于java.util包下：

public interface Comparator<T>{
    int compare(T o1, T o2);
    ......//还有其他方法
}

自定义一个类分别演示下两个接口的用法：

一、实现Comparable接口：

1.

public class User implements Comparable{
private String id;
private String name;
private int age;

public User(String id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int compareTo(Object o) {
return this.age - ((User) o).getAge(); 
}
}


import java.util.Arrays;

public class SampleComparable {
public static void main(String[] args) {
User[] users = new User[] { new User("a","name1", 30), new User("b","name2", 20),new User("c","name3", 25) };  
   Arrays.sort(users);  
   for (int i = 0; i < users.length; i++) {  
     User user = users[i];  
     System.out.println(user.getId() + " " + user.getAge());  
   } 
}
}

2.

public class Test {
    public static void main(String[] args){
        List<Person> list = new ArrayList<Person>();
        list.add(new Person(20));
        list.add(new Person(19));
        list.add(new Person(21));
        for(Person p : list)
            System.out.println(p.getAge());
        Collections.sort(list);
        for(Person p : list)
            System.out.println(p.getAge());
    }
}

class Person implements Comparable<Person>{
    private int age;

    public Person(int age){
        this.age = age;
    }
    public int compareTo(Person anotherPerson){
        if(age == anotherPerson.age)
            return 0;
        else if(age < anotherPerson.age)
            return -1;
        else
            return 1;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

二、实现Comparator接口：

1.

import java.util.Arrays;
import java.util.Comparator;


public class SampleCompartor {
public static void main(String[] args) {
String[] array = new String[] { "BCD", "ABC", "Cdb" };
Arrays.sort(array, new Comparator<String>(){
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});

for(int i=0;i<array.length;i++){
System.out.println(array[i]);
}
}
}

2.

public class Test {
    public static void main(String[] args){
        List<Person> list = new ArrayList<Person>();
        list.add(new Person(20));
        list.add(new Person(19));
        list.add(new Person(21));
        for(Person p : list)
            System.out.println(p.getAge());
        Collections.sort(list, new PersonComparator());
        for(Person p : list)
            System.out.println(p.getAge());
    }
}

class Person{
    private int age;

    public Person(int age){
        this.age = age;
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class PersonComparator implements Comparator<Person>{
    public int compare(Person p1, Person p2){
        if(p1.getAge() == p2.getAge())
            return 0;
        else if(p1.getAge() < p2.getAge())
            return -1;
        else
            return 1;
    }
}

两者的选择： 
两种方法各有优劣, 用Comparable 简单, 只要实现Comparable 接口的对象直接就成为一个可以比较的对象,但是需要在类内部进行方法的定义,如遇到复杂的比较逻辑，代码看起来会比较混乱冗余， 用Comparator 的好处是不需要将比较方法定义在类内，代码的分离性较好。