Comparable 与 Comparator 的区别

为了方便实例的排序，我们常常使用到 Comparable<> 或者

Comparator<> 这两个接口,这两个看似很相似，其实是有很大区别的

Comparable

这个接口的位置为 java.lang.Comparable ,如果一个类实现的

这个接口，这个类的实例就具备与同一个类的其它实例的比较能力。我们需要实现 Comparable 接口中的 int compareTo(Object o1) 这个方法；

如果有一个类实现的这个接口，它两个实例为A，B，对它们进行比较 A.comparaTo(B) 它返回有三种可能：

1） positive – 当前对象大于o1;

2) zero – 当前对象等于o1;

3) negative – 当前对象小于o1;

如果我们有一个实现了该接口类的对象集合list，我们就可以使用 Collections.sort(list) 对集合进行排序，如果是数组我们可以使用 Arrays.sort(Object[]) 对数组进行排序； Compareble 相当于一个内部比较器，它是实例所拥有的，实例自己具有与别的实例的比较的能力；

Comparator

这个接口位置 java.util.Comparator 顾名思义，它是一个比较器，它不被某个实例所拥有，它相当于一个外部定义的比较某种东西的工具；

需要实现它的 int compare(Object o1, Objecto2) 方法：返回值

1） positive – o1大于o2

2） zero – o1等于o2

3） negative – o1小于o2

我们需要比较某两个相同类的实例 A B 的时候，需要使用 compare(A,B) ；

当我们有一个对象集合，我们需要对它进行排序，可以使用 java.util.Collections.sort(List,Comparator) 或者

java.util.Arrays.sort(Object[], Comparator)

实例

1）我们定义一个People类，它实现了Comparable接口，所以每一个People的实例有具有与People实例比较的能力；

class People implements Comparable<People>{
private String name;
private int age;

public People(String name,int age) {
this.name = name;
this.age = age;
}

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

public String getName() {
return this.name;
}

public String toString(){
return this.name + "-" + this.age;
}
/**
* 实现comparaTo方法，我们依据实例的name比较
* 因为name为String对象
* 所以可以调用name 的 comparaTo 方法
* **/
@Override
public int compareTo(People p) {
return this.name.compareTo(p.name);
}
/**
* 重写equals()方法，因上面我们使用 它们的name比较，所以equals 中，
* name相同,我们返回true
* **/
public boolean equals(People p) {
if(p == this) return true;
if(p instanceof People) {
if(this.name.equals(p.name)) return true;
}
return false;
}
}

2） 我们写一个类实现Comparator接口，让People对象能基于年龄比较

class AgeSortPeople implements Comparator<People>{
@Override
public int compare(People o1, People o2) {
return o1.getAge() - o2.getAge();
}
}

3）测试

public class DD {
public static void main(String[] args) {
/**
* 创建一个People对象list
* */
List<People> list = new ArrayList<>();
list.add(new People("AB",40));
list.add(new People("CC",40));
list.add(new People("AA",10));
list.add(new People("AC",30));
list.add(new People("BB",20));
System.out.printf("Original  sort, list:%s\n", list);
//集合排序的时候使用的是People对象自身的比较器 Comparable 中的 compareTo 方法
Collections.sort(list);
System.out.printf("Name  sort, list:%s\n", list);
//集合排序的时候我们传入了一个我们自定义的外部比较器
Collections.sort(list, new AgeSortPeople());
System.out.printf("Age  sort, list:%s\n", list);
}

}

输出

Original  sort, list:[AB-40, CC-40, AA-10, AC-30, BB-20]
Name  sort, list:[AA-10, AB-40, AC-30, BB-20, CC-40]
Age  sort, list:[AA-10, BB-20, AC-30, AB-40, CC-40]