考虑实现Comparable 接口

1、Comparable接口

public interface Comparable<T> 
    public int compareTo(T o);

现在对comparaTo()方法进行简单说明。

comparaTo()方法传入该类的另外一个实例，返回一个int值，这个方法每执行一次都是对传入的对象和和本生对象进行比较。返回的int值如果是一个正值（不包括零）则在数组或是集合中交换两个实例的位置，否则位置保持不变。

CompareTo方法返回三个结果，1,0，-1，那么它们分别代表什么意思呢？

首先我们要知道我们比较的是this对象( 当前对象 )和被比较的对象。

• 其中，0表示两者相等
• -1表示当前对象排在被比较对象之前
• 1表示当前对象排在被比较对象之后

2、为什么要考虑实现Comparable接口

实现了Comparable接口的类，可以很好的和集合类或是一些泛型算法很好的协作，你可以付出很小的代价实现强大的功能。

一个类，如果实现了Comparable接口，我们可以很容易的将它在数组或是集合中进行排序。Comparable这个接口是用来实现对象排序的。 假设有这么一个类：

public class CompObj implements Comparable<CompObj> 
  private int age;
  private String name;
  public CompObj(int age, String name) 
    this.age = age;
    this.name = name;
  
  public int getAge() 
    return age;
  
  public String getName() 
    return name;
  

  //重点在这，这是接口中唯一的一个方法
  @Override
  public int compareTo(@NonNull CompObj another) 
    return this.age - another.age;
  

然后我们可以这样对他进行排序：

List<CompObj> list = ...;//初始化一个list
Collections.sort(list); //集合排序，就是这么简单
CompObj array[] = ...;//初始化一个数组
Arrays.sort(list)； //数组排序，就是这么简单

3、compareTo 方法的通用约定

Comparable接口中的compareTo方法其实与我们之前所介绍的equals类似，按照两个对象的比较大小返回相应的结果，分别是0，正整数，负整数，如果无法比较的话就抛出一个ClassCastException

在这里我们引入一个数学函数signum也就是sgn符号函数，该函数根据自变量的符号分别返回-1，0，+1

接下来，利用这个数学函数，我们介绍一下实现Comparable接口的一些约定

• 所有的x，y需满足，sgn(x.compareTo(y)) == -sgn(y.compareTo(x))
• 传递性：x.compareTo(y) > 0 并且 y.compareTo(z) > 0,则有 x.compareTo(z) >0
• 对于任意z，当x.compareTo(y)==0时，均有sgn(x.compareTo(z))==sgn(y.compareTo(z))
• 强烈建议，x.compareTo(y)==0等价于x.equals(y) ,虽然这个不是必要的，但是如果违反这一条件，应该做出适当说明
  • (x.compareTo(y) == 0) == (x.equals(y))

对着上面的约定中的最后一项，并不是真正的规则，而是同equals返回的结果一致，保持一种一致的顺序关系，当然了，一个类违反了这个小规则，也可以继续正常工作

4、何时以及如何实现Comparable接口

什么时候应该考虑实现Comparable接口

• （1）你写的类是一个值类。
• （2）类中有很明显的内在排序关系，如字母排序、按数值顺序或是时间等。
• （3）前面两者是并且关系。

示例

我们定义一个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<Person>
    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<Person> 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<Person> 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;
    

我们上面实现的是对person中的age升序排列，因为当this.age<o.age时，返回的是-1，表示this对象排在对象o前面。也就是较小的数排在前面。那么如果我们要改为降序呢？

@Override
    public int compareTo(Person o) 
        if (this.age < o.age)
            return 1;
        else if (this.age > o.age)
            return -1;
        else return 0;
    

4.1、多重比较

对于，上面的Person类，可能出现age相同的情况，如果我还想继续排序，假设age相同时，对name进行排序。那么这种情况又应该如何实现呢？

public class Person implements Comparable<Person>
    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<Person> 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<Person> 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<Person>
    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<Person> 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<Person> 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。

5、实现Comparable接口所需满足的需求

（1）满足对称性。

• 即对象A.comparaTo(B) 大于0的话，则B.comparaTo(A)必须小于0;

（2）满足传递性。

• 即对象A.comparaTo(B) 大于0，对象B.comparaTo(Z)大于0，则对象A.comparaTo(Z)一定要大于0；

（3）建议comparaTo方法和equals()方法保持一致。

• 即对象A.comparaTo(B)等于0，则建议A.equals(B)等于true。

（4）对于实现了Comparable接口的类，尽量不要继承它，而是采取复合的方式。

6、总结

对于如何写好CompareTo方法提供一下几个建议：

• 1、如果对象有多个域，从关键域开始比较。
• 2、对于对象的引用域可以依次递归调用引用域的CompareTo方法
• 3、在java7之前，可以用关系操作符<和>去比较整数型基本类型的域
  • 用静态方法Double.compare和Float.compare去比较浮点基本类型域；
• 4、在java7之后，已经在Java的所有装箱基本类型的类中增加了静态的compare方法。在compareTo方法中使用关系操作符<和>是非常繁琐的，并且容易出错，因此不再建议使用。

// Comparator based on static compare method
static Comparator<Object> hashCodeOrder = new Comparator<>() 
    public int compare(Object o1, Object o2) 
        return Integer.compare(o1.hashCode(), o2.hashCode());
    
;

 @Test
    public void testComparator() 
        String[] arr = new String[]"aa", "cc", "mm", "gg", "zz", "ww", "bb";
        Arrays.sort(arr, new Comparator() 
            //            按照字符串从大到小的顺序排列
            @Override
            public int compare(Object o1, Object o2) 
                if (o1 instanceof String && o2 instanceof String) 
                    String s1 = (String) o1;
                    String s2 = (String) o2;
                    return -s1.compareTo(s2);
                
                throw new RuntimeException("输入的数据类型不一致");
            
        );
        System.out.println(Arrays.toString(arr));
    

5、在java8之后，引入lamda表达式，Compartor接口配置了一组比较构造器，使得比较器的构造工作变得非常流程。

// Comparator based on Comparator construction method
static Comparator<Object> hashCodeOrder =
        Comparator.comparingInt(o -> o.hashCode());

总而言之，无论何时实现具有合理排序的值类，你都应该让该类实现 Comparable 接口，以便在基于比较的集合中轻松对其实例进行排序，搜索和使用。

• 比较 compareTo 方法的实现中的字段值时，请避免使用「<」和「>」运算符。
• 相反，使用包装类中的 静态 compare 方法 或 Comparator 接口中的构建方法。

参考

1、《Effective Java》阅读笔记12 考虑实现Comparable接口
2、Effective.Java 读书笔记（12）关于Comparable接口
3、第十二条：考虑实现Comparable接口