一、背景

本文是为了解决以下几个疑问：

== 和equals的差别
实现compareTo 和 equals 的关系
equals 和hashCode的关系，为什么在实现equals的同进强列建议实现hashCode
comparator 和comparable的本质差别在哪里
搞清这些问题有助于在以后的工作中不至于犯错，虽然问题看似简单，但看了不少网上的文章，发现很多仍然无法搞清楚，也具有误导性。因此这里再作一次梳理

== 和 equals

== 本质是判断两个对象引用引用是否是同一对象，即指向是不是同一个对象地址；
equals 是Object的默认方法，因此任意对象都可以调用equals,
我们先看以下示例：

Person p1  = new Person("a", 20);
Person p2 = new Person("a", 20);
Person p3 = p1;

System.out.printf("p1 == p2 : %b \n", p1 == p2);
System.out.printf("p1 == p3 :  %b \n", p1 == p3);
System.out.printf("p1 equals p2 : %b\n", p1.equals(p2));
System.out.printf("p1 equals p2 : %b\n", p1.equals( p3));

结果

p1 == p2 : false
p1 == p3 :  true
p1 equals p2 : false
p1 equals p2 : true

因为p1 与 p2的存储位置不一样，所以p1 != p2；p1和p3同时指向p1所以相等；
但equals为什么和== 一致呢？
看一下equals的底层实现

public boolean equals(Object obj) {
    return (this == obj);
}

可以看到object.equals 本质上就是 ==

再看一个string的例子

String p1  = new String("a");
String p2 = new String("a");
System.out.printf("p1 equals p2 : %b\n", p1.equals(p2));

结果

p1 equals p2 : true

p1和p2指向堆内两块不同的内存，但为啥此时相同了呢，这是因为String覆盖Object equals方法

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

String判断如果每个字符都相等，那两个字符串对象就相等。

三、compareTo 和 equals

往往当我们创建一个类的时候，在使用类的实例的时候，需要对实例的大小做比较，这时候就会想到实现一个compareTo接口吧，但实现了之后却发现没那么简单，这时候IDE往往提示你去实现equals,
为啥当你实现了compareTo,还会强烈建议实现equals呢？
看以下例子

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

public String getName() {
    return name;
}

public int getAge() {
    return age;
}

public void setName(String name) {
    this.name = name;
}

public void setAge(int age) {
    this.age = age;
}

public int compareTo(Person p) {
    return name.compareTo(p.getName());
}

Person p1  = new Person("a", 20);
Person p2 = new Person("a", 20);
Person p3 = new Person("a", 22);
System.out.printf("p1 compareTo p2 : %d\n", p1.compareTo(p2));
System.out.printf("p1 equals p2 : %b\n", p1.equals(p2));
System.out.printf("p1 compareTo p3 : %d\n", p1.compareTo(p3));

p1 compareTo p2 : 0
p1 equals p2 : false
p1 compareTo p3 : 0

上面的示例可以得出以下结论

p1.compareTo(p2) == 0 并不等价于 p1.euqals(p2) == true,甚至可以说毫无关系.因为equals仍然在使用Object的方法。这种情况会对使用该类而不清楚具体实现的造成误导，而导致错误。
自身实现的compareTo,并非是严格的，依赖于某种例用环境（无同名的人）
compareTo 的实现应该与对象紧密相关，而不应依赖某种环境，否则就不应该成功类自身一种方法。

根据上述结论可知，当类实现compareTo时，也需要override equals，因为在类本身p1.compareTo(p2) 与 p1.equals(p2) = true 对类本身应该具有等价关系。如下:

class Person implements Comparable<Person>{
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int compareTo(Person p) {
        return name.compareTo(p.getName());
    }

    @Override
    public boolean equals(Object p) {
        return this.compareTo((Person)p) == 0;
    }
}

三、equals与hashCode

hashCode与equals本身并没有任何关系，hashCode 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。

虽然，每个Java类都包含hashCode() 函数。但是，仅仅当创建并某个“类的散列表”(关于“散列表”见下面说明)时，该类的hashCode() 才有用(作用是：确定该类的每一个对象在散列表中的位置；其它情况下(例如，创建类的单个对象，或者创建类的对象数组等等)，类的hashCode() 没有作用。

上面的散列表，指的是：Java集合中本质是散列表的类，如HashMap，Hashtable，HashSet。
也就是说：hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

hashCode与equals 之间有个契约：If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.

因此当我们Override 而不Override hashCode,那就极有可能违背这个契约。

那为啥一定要遵循这个契约呢？这就和hashCode在散列表中的作用有关系了。
用hashSet举个例子

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj){
        if(obj == null){
            return false;
        }

        //如果是同一个对象返回true，反之返回false
        if(this == obj){
            return true;
        }

        //判断是否类型相同
        if(this.getClass() != obj.getClass()){
            return false;
        }

        Person person = (Person)obj;
        return name.equals(person.name) && age==person.age;
    }
}

Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 100);
Person p3 = new Person("aaa", 200);

// 新建HashSet对象
HashSet set = new HashSet();
set.add(p1);
set.add(p2);
set.add(p3);

// 比较p1 和 p2， 并打印它们的hashCode()
System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
// 打印set
System.out.printf("set:%s\n", set.toString());

行结果

p1.equals(p2) : true; p1(1604125387) p2(1668627309)
set:[com.fuxx.learn.pigeon.Person@5f9d02cb, com.fuxx.learn.pigeon.Person@63753b6d, com.fuxx.learn.pigeon.Person@6b09bb57]

我们知道set集合不存在相等的对象，上述例子p1=p2,但其hashCode不一致，导致插入集合后，出现两个相同的对象，这就是一个严重的错误。
那接下来我们实现hashCode

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj == null){
            return false;
        }

        //如果是同一个对象返回true，反之返回false
        if(this == obj){
            return true;
        }

        //判断是否类型相同
        if(this.getClass() != obj.getClass()){
            return false;
        }

        Person person = (Person)obj;
        return name.equals(person.name) && age==person.age;
    }


    @Override
    public int hashCode(){
        int nameHash =  name.toUpperCase().hashCode();
        return nameHash ^ age;
    }

结果.

p1.equals(p2) : true; p1(68545) p2(68545)
set:[com.fuxx.learn.pigeon.Person@10bc1, com.fuxx.learn.pigeon.Person@fce9]

可以看到set集合中只剩下两个对象了。
hash表是根据hashcode寻址的，hashCode相同的基础上如果p1.equals也相同，才会认为相同，否则的话在插入的时候就会采用相应的策略解决哈希冲突。看下面的例子

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj == null){
            return false;
        }

        //如果是同一个对象返回true，反之返回false
        if(this == obj){
            return true;
        }

        //判断是否类型相同
        if(this.getClass() != obj.getClass()){
            return false;
        }

        Person person = (Person)obj;
        return name.equals(person.name);
    }


    @Override
    public int hashCode() {
        int nameHash =  name.toUpperCase().hashCode();
        return nameHash^age;
    }
}

Person p1 = new Person("eee", 100);
Person p2 = new Person("eee", 200);

// 新建HashSet对象
HashSet set = new HashSet();
set.add(p1);
set.add(p2);

// 比较p1 和 p2， 并打印它们的hashCode()
System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
// 打印set
System.out.printf("set:%s\n", set.toString());

结果

p1.equals(p2) : true; p1(68545) p2(68461)
set:[com.fuxx.learn.pigeon.Person@10bc1, com.fuxx.learn.pigeon.Person@10b6d]

在p1 与p2相等的情况下插入了两个.

同样，当进行查找的时候，也有可能导致意想不到的错误

因此当我们实现了某个类时，就需要同时实现equals和hashCode(虽然很多时候用不到)

四、Comparator和Comparable

从上面看出，为了进行一个简单的排序而实现Comparable接口的代价很高，不仅仅要实现compareTo,equals,hashCode,而且对其相互之间的依赖关系也有一定的要求，可是我们又希望在某种特定的环境下进行排序，那怎么办呢？

那就可以使用Comparator,Comparator只是一个比较类，我们只需要依据某特定环境实现这个比较类即可。

Comparator 和 Comparable的本质区别是，Comparator和对象没有任保关系，只是一个特定的比较器，Comparable是对象的一个方法，和对象密切相关，不可依赖于特定环境。

因此在大部分情况下，为了实现排序，只需要实现Comparator.
那有没有必要建立外部类呢？答案当然是NO，因为该比较器只依赖于某种特定环境，因此其实现应该紧接上下文，用内部类或lamda表达式实现

Person p1 = new Person("aaa", 21);
Person p2 = new Person("bbb", 18);
Person p3 = new Person("ccc", 25);
ArrayList<Person> persons = new ArrayList<Person>();
persons.add(p1);
persons.add(p2);
persons.add(p3);

Collections.sort(persons, (a, b) -> a.getAge() - b.getAge());

至于为什么不用内部类，把lamda写成这样？参考