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);
    ......//還有其餘方法
}

自定義一個類分別演示下兩個接口的用法：

1、實現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;
    }
}

2、實現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 的好處是不須要將比較方法定義在類內，代碼的分離性較好。