猿创征文 |深入理解= = 、equals()与hashcode()的关系

最近也是在读Hollis的《深入理解Java核心技术》里面一节讲到了equals()和hashcode()的关系，对于这个高频面试点，咱们需要认真理清一下几者之间的关系

首先来看==

1.= =

=为赋值运算符，==为比较运算符，仅比较对象的内存地址，无法比较真正意义上的相等！
JDK里的equals方法就是通过==来实现的比较对象的内存地址
以Integer为例

Integer a = 127;
Integer b = 127;
System.out.println(a == b);//true

Integer c = 128;
Integer d = 128;
System.out.println(c == d);//false
1
2
3
4
5
6
7

这里也是通过== 引出一个知识点，一个数值之差为啥导致结果不一样？在[-128,127]的区间内Integer a = 127;由于设计了缓存，而后的Integer b = 127;就是直接利用的缓存里的数值对象，所以通过==比较的结果为true，因为他们本质还是一个数值对象

而Integer c = 128;Integer d = 128;就没这样幸运了，超过了缓存区间会重新new出对象，以至于两者虽然数值相同但是地址不同

所以啊，==比较的是地址！也只是地址！

在前面==的基础上，再来看equals（）

2.equals()

以一个String类型的变量为例，当我们来使用equals()比较两个对象时，结果肯定是false，因为equals()方法比较的是内存地址，这里的person1，person2均是两次new出来的，所以地址肯定是不相同的，而person1，person3指向同一空间地址一定是相同的

Person person1 = new Person("lyy");
Person person2 = new Person("lyy");
Person person3 = person1;
System.out.println(person1.equals(person2));//false	
System.out.println(person1.equals(person3));//true
1
2
3
4
5

在不重写的情况下，我们Ctrl+B看一下equals()的源码：

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

显而易见的是 (this = = obj)是该方法的核心，而 = = 又是两个对象比较的方式，= = 嘛比的是内存地址，懂的都懂噢

3.重写equals()

记不记得你在刷面经或者短视频的时候经常看到的一句话——比较两个对象的内容是否相等时我们要重写equals()方法！

这是为何？那我们不妨来重写一下equals()试试水

@Override
public boolean equals(Object obj){
    if (this==obj){
        return true;
    }
    if (obj==null||getClass()!= obj.getClass()){
        return false;
    }
 Person person=(Person)obj;
    return Objects.equals(name,person.name);
}
1
2
3
4
5
6
7
8
9
10
11

重写过equals后，原有的两者就已发生翻天覆地的变化，从原来的比较内存地址——>比较对象内容，这是一件很神奇的事情，因为实现了比较不同对象的相同或者不同内容！

重写之后:

具体是如何实现的呢？就像下面这样…

4.equals()比较流程

下面我们来探索一下重写的equals()是如何比较内容的：

通过debug来深入理解一下

下面来看一下debug过程中变量情况

总的来说，通过debug，重写equals()来比较不同变量的不同或者相同内容得到了进一步论证！

5.hashcode()

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashCode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashCode 值作比较，如果没有相符的 hashCode，HashSet 会假设对象没有重复出现。但是如果发现有相同 hashCode 值的对象，这时会调用 equals() 方法来检查 hashCode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。
————《Head First Java》
我们在IDEA中通过CTRL+O的快捷键重写hashcode()时它上面所属的类是谁？

java.lang.Object!

显而易见，该方法是Object类所定义的方法，作用是返回对象的哈希值返回值的类型为int（哈希值的作用是确定该对象在哈希表中的位置），曾经有这样一句流川千古的话：你必须在每个重写equals()的类中重写一遍hashcode()方法

如果不这样做将会违反Object.hashcode()的一般约定，这会阻止lei与所有基于散列的集合（比如hashmap,hashset…）一起正常工作。为啥？因为hashmap,hashset等基于散列的集合中，会使用对象的hashcode值来确定该对象应该如何存储到集合中，并且再次使用hashcode来定位对象在集合中的位置

那么

在一个类中重写了equals()但没重写hashcode()会出现啥情况呢？

我们来通过一个例子试试水~

尝试把对象都放入一个不能重复的set里，然后看集合的长度来判断两个对象是否相等！

public class equals_hashcode {
    public static void main(String[] args) {

        Person person1 = new Person("lyy");
        Person person2 = new Person("lyy");
        HashSet<Person> set = new HashSet<>();
        set.add(person1);
        set.add(person2);
        System.out.println(set.size());
    }
}

class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        Person person = (Person) obj;
        return Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

情况一：
当只重写了equals()方法时运行的结果为2，由此得出两个对象不相等！,
为什么不相等？
因为我并不知道两者的哈希值是否相等，我需要重写hashcode()方法来确保他们的hash值是否相等！

情况二：
当既重写了equals()和hashcode()后运行结果为1，所以两个对象相等！
这里为什么又相等了？
是因为我重写了hashcode()方法，确保了他们的hash值是相等的，由此得出了两个对象相等！

由此得出，对象相等的本质是：
1.地址相同
2.哈希值相同（重写hashcode的体现）
这也不难联系到之前的约定了，在比较对象是否相等的场景下，我们必须重写equals()和hashcode()!

对象相等建立在==之上，equals(),hashcode()的双重写是对象相等的基本准则！