《Effective Java》阅读笔记12 考虑实现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 方法的通用约定

• 实现者必须确保所有的x和y都满足sgn(x.compareTo(y)) == -sgn(y.compareTo(x))
• 实现者必须确保这个比较关系是可以传递的
• 实现着必须确保x.compareTo(y) == 0 暗示着所有的z都满足sgn(x.compareTo(z)) == sgn(y.compareTo(z))
• 强烈建议 (x.compareTo(y) == 0) == (x.equals(y)) ,但这并非必要

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

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

5.如何实现Comparable接口

5.1示例
我们定义一个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;
    }

实际上，只要修改下比较号即可。

5.2多重比较
对于，上面的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。

以上示例摘自大佬https://www.jianshu.com/p/f0d39ab402eb

6.实现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接口的类，尽量不要继承它，而是采取复合的方式。

7.总结

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

• 如果对象有多个域，从关键域开始比较。
• 对于对象的引用域可以依次递归调用引用域的CompareTo方法
• 在java7之前，可以用关系操作符<和>去比较整数型基本类型的域，用静态方法Double.compare和Float.compare去比较浮点基本类型域；
• 在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());
    }
};

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

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

总而言之，无论何时实现具有合理排序的值类，你都应该让该类实现 Comparable 接口，以便在基于比较的集合中轻松对其实例进行排序，搜索和使用。 比较 compareTo 方法的实现中的字段值时，请避免使用「<」和「>」运算符。 相反，使用包装类中的 静态 compare 方法 或 Comparator 接口中的构建方法。

8.参考文献

https://www.jianshu.com/p/f0d39ab402eb
http://www.jianshu.com/p/0c0bcc45700f
http://www.taodudu.cc/news/show-2269808.html

本公众号分享自己从程序员小白到经历春招秋招斩获10几个offer的面试笔试经验，其中包括【Java】、【操作系统】、【计算机网络】、【设计模式】、【数据结构与算法】、【大厂面经】、【数据库】期待你加入！！！

1.计算机网络----三次握手四次挥手
2.梦想成真-----项目自我介绍
3.你们要的设计模式来了
4.一字一句教你面试“个人简介”
5.接近30场面试分享