什么是Comparable接口？
Comparable接口一般用于表示某个实例具有内在的排序关系。
为什么需要实现Comparable接口？
我们知道，对于普通的数值或者字符串，都可以进行一定的排序。但是，能不能直接给对象进行排序呢？答案当然是不能的了，实际上，之所以我们可以对数值和字符串进行排序，是因为系统内部已经为我们定义了数值和字符串的排序关系。而我们定义的对象，本身是不包含排序关系的，因此，我们无法直接对对象进行排序。
因此，如果我们需要对对象进行排序的话，就必须定义对象的内在排序关系，即实现Comparable接口。
如何实现Comparable接口？
我们举个具体的例子，我们定义一个person对象，要求person按照年龄来进行排序。
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
对于，上面的对象，我们是不能直接进行排序的，必须要实现其Comparable接口：
public class Person implements Comparable{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person o) {
if (this.age > o.age)
return 1;
else if (this.age < o.age)
return -1;
else return 0;
}
@Override
public String toString() {
return "name: " + name + " age: " + age;
}
public static void main(String[] args){
List list = new ArrayList<>();
list.add(new Person("John",18));
list.add(new Person("Marry",21));
list.add(new Person("Tom",20));
System.out.println("Before sort:");
printList(list);
Collections.sort(list);
System.out.println("After sort:");
printList(list);
}
public static void printList(List list){
for (Person p : list){
System.out.print(p + " / ");
}
System.out.println();
}
}
输出结果：
Before sort:
name: John age: 18 / name: Marry age: 21 / name: Tom age: 20 /
After sort:
name: John age: 18 / name: Tom age: 20 / name: Marry age: 21 /
为了方便测试，我们重写了toString方法，然后调用Collections.sort()方法来对list进行排序。
现在我们重点来看实现Comparable接口中的CompareTo方法：
@Override
public int compareTo(Person o) {
if (this.age > o.age)
return 1;
else if (this.age < o.age)
return -1;
else return 0;
}
CompareTo方法返回三个结果，1,0，-1，那么它们分别代表什么意思呢？
- 首先我们要知道我们比较的是this对象( 当前对象 )和被比较的对象。
- 其中，0表示两者相等
- -1表示当前对象排在被比较对象之前
- 1表示当前对象排在被比较对象之后
我们上面实现的是对person中的age升序排列，因为当this.age
@Override
public int compareTo(Person o) {
if (this.age < o.age)
return 1;
else if (this.age > o.age)
return -1;
else return 0;
}
实际上，只要修改下比较号即可。
多重比较
对于，上面的Person类，可能出现age相同的情况，如果我还想继续排序，假设age相同时，对name进行排序。那么这种情况又应该如何实现呢？
public class Person implements Comparable{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person o) {
if (age > o.age)
return 1;
if (age < o.age)
return -1;
return name.compareTo(o.name);
}
@Override
public String toString() {
return "name: " + name + " age: " + age;
}
public static void main(String[] args){
List list = new ArrayList<>();
list.add(new Person("John",18));
list.add(new Person("Marry",21));
list.add(new Person("Tom",20));
list.add(new Person("Mark",20));
list.add(new Person("Ruby",20));
System.out.println("Before sort:");
printList(list);
Collections.sort(list);
System.out.println("After sort:");
printList(list);
}
public static void printList(List list){
for (Person p : list){
System.out.print(p + " / ");
}
System.out.println();
}
}
输出结果：
Before sort:
name: John age: 18 / name: Marry age: 21 / name: Tom age: 20 / name: Mark age: 20 / name: Ruby age: 20 /
After sort:
name: John age: 18 / name: Mark age: 20 / name: Ruby age: 20 / name: Tom age: 20 / name: Marry age: 21 /
我们可以看到，当age相同时，Mark，Ruby和Tom按照名字中的字母进行排序。达到了我们需要的效果，我们具体来看下是如何实现的：
@Override
public int compareTo(Person o) {
if (age > o.age)
return 1;
if (age < o.age)
return -1;
//若年龄相等，则直接通过名字来进行排序。
return name.compareTo(o.name);
}
实际上，也就是当年龄相等时，调用name的compare方法来进行排序。为什么这里可以直接调用compare方法呢？因为字符串在系统中已经设置好了内部排序。这里默认为升序，那如果需要设置降序呢？
return -name.compareTo(o.name);
修改为其相反数即可。
再度升级，如果为Person类添加一个id属性，并要求先按id升序，若id相同，则按年龄降序，若id和age都相同，则按name升序。
public class Person implements Comparable{
private int id;
private String name;
private int age;
public Person(int id,String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person o) {
if (id > o.id)
return 1;
if (id < o.id)
return -1;
//id相等的情况下，对age进行排序
if (age > o.age)
return -1;
if (age < o.age)
return 1;
//若id和age相等，则直接通过名字来进行排序。
return name.compareTo(o.name);
}
@Override
public String toString() {
return "id: " + id + " name: " + name + " age: " + age;
}
public static void main(String[] args){
List list = new ArrayList<>();
list.add(new Person(3,"John",18));
list.add(new Person(2,"Marry",21));
list.add(new Person(2,"Tom",20));
list.add(new Person(4,"Mark",20));
list.add(new Person(4,"Ruby",20));
System.out.println("Before sort:");
printList(list);
Collections.sort(list);
System.out.println("After sort:");
printList(list);
}
public static void printList(List list){
for (Person p : list){
System.out.print(p + " / ");
}
System.out.println();
}
}
输出结果：
Before sort:
id: 3 name: John age: 18 / id: 2 name: Marry age: 21 / id: 2 name: Tom age: 20 / id: 4 name: Mark age: 20 / id: 4 name: Ruby age: 20 /
After sort:
id: 2 name: Marry age: 21 / id: 2 name: Tom age: 20 / id: 3 name: John age: 18 / id: 4 name: Mark age: 20 / id: 4 name: Ruby age: 20 /
我们可以看到首先根据id进行升序排序，当id相同时，根据age进行降序排序，如Marry和Tom，若id和age都相同，则对name进行升序排序，如Mark和Ruby。
实现Comparable接口所需满足的需求：
- 满足对称性：必须确保所有的x和y都满足sgn(x.compareTo(y)) == -sgn(y.compareTo(x));
- 满足传递性：若(x.compareTo(y) >0 && y.compareTo(z)>0)，则x.compareTo(z)>0。
- 若x.compareTo(y)==0,则sgn(x.compareTo(z)) == sgn(y.compareTo(z));