Java中equals和hashcode方法的来龙去脉

结绳记事，唯有记录、思考，方能成长~

我们在开发过层中，经常用到要重写某个对象的equals方法和hashcode方法，并且在开发规约中，也会强制“只要重写了equals方法，就必须重写hashcode方法”，尤其针对map的键及set存储的对象。今天就梳理下equals和hashcode的来龙去脉。

一、WHY 为什么要重写equals和hashcode方法

Object类是java中的万类之祖，其中有2个重要的方法equals和hashcode，所有的子类中如果没有重写这2个方法的情况下，都是使用Object类的实现逻辑，我们看下它是如何实现的

/**
	* ……
     * Note that it is generally necessary to override the {@code hashCode}
     * method whenever this method is overridden, so as to maintain the
     * general contract for the {@code hashCode} method, which states
     * that equal objects must have equal hash codes.
     * 如果重写了equals方法，非常有必要重写hashcode方法。
     * 公约：如果equals相等的对象，hashcode也必须相等。
     * ……
*/
public boolean equals(Object obj) {
        return (this == obj);
    }

/**
* 本地方法
*/
public native int hashCode();

默认的equals方法，是严格判断一个对象是否相等的方法，只有this 和 obj引用同一个对象，才会返回TRUE；
默认的hashcode方法，是根据内存地址换算出来的一个值。

但在我们实际业务中，我们关心的并不是2个对象的内存地址相等，而是它们的属性是否相等。所以，如此严格的相等，我们并不需要。

二、WHAT 重写的规约是什么

equals方法

关于重写，Object类中equals方法注释上有具体的指导原则(公约)，如下：

1. 自反性(reflexive)：x.equals(x)一定是true。自反性这个翻译不太好，有点让人难捉摸，总之就是自己肯定跟自己相等。
2. 对称性(symmetric)：x.equals(y) 和 y.equals(x)结果一致。
3. 传递性(transitive)：a 和 b equals，b 和 c equals，则a 和 c 也一定equals。
4. 一致性(consistent)：如果对比的对象的信息没有被修改的话，不管进行多少次对比，总能一致的返回true 或 false。
5. 空值：对于任意空值，x.equals(null)，返回结果一定是false

hashcode方法

这个方法返回对象的散列码，返回值是int类型的散列码。对象的散列码是为了更好地支持基于哈希机制的Java集合类，例如HashTable、HashMap、HashSet等。
关于重写，Object类中的hashcode方法注释上也有具体的指导原则(公约)，如下：

1. 在某个运行期间，只要对象的(字段的)变化不会影响equals方法的决策结果，那么，在这个期间，无论调用多少次hashcode方法，都必须返回同一个散列码。
2. 如果2个对象通过equals调用后返回的是true，那么这2个对象的hashcode方法也必须返回同样的散列码。
3. 如果2个对象通过equals调用后返回的是false，它们的hashcode返回的值，允许相等。(这个就是我们常说的HashMap中关于Hash碰撞的场景，在hashcode相等的情况下，会放在同一个数组下标对应的链表中。当然，如果hash碰撞的概率越小，会让数据分散的更均匀，从而提高集合中读、写的效率)

三、HOW 如何重写

重写equals方法

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        
        if ((obj == null) || (obj.getClass() != this.getClass())) {
            return false;
        }
        
        // 能执行到这里，说明obj和this是同类并且非null
        Test test = (Test) obj;
        return (age == test.age) && (name == test.name || (name != null && name.equals(test.name)));
    }

Test类中有2个字段，name和age，这2个字段代表了对象的状态，它们也用在equals方法中作为评判的依据。

在equals方法中，首先是比较传入的对象的引用是否和this相等，这样做是为了save time，节约执行时间，如果this和obj是对同一个堆对象的引用，那么，它们一定是equals的。

接着，判断obj是否为null，如果为null，一定不equals，因为既然当前对象能够调用equals方法，当前对象一定非null，非null和null肯定不equals。

然后，比较2个对象的运行时类，是否为同一个类。不是同一个类，则不equals。

最后，判断2个对象中的属性是否相等。当然，这里并不一定要判断所有字段，只需要判断我们业务上能够用来区分对象的属性即可。

有些人会用下面的第二种方式来代替运行时类的比较，应该避免这样做。

        // 第一种方式
        if ((obj == null) || (obj.getClass() != this.getClass())) {
            return false;
        }
        
        // 第二种方式，应该避免
        if (!(obj instanceof Test)) {
            return false;
        }

它违背了公约中的对称性原则。
例如：假设Student 继承了 Person类。那么：
Student.equals(Person) 为true。
Person.equals(Student) 为false。
所以针对子类继承父类的场景下，这种判断方式是有问题的，因而应该从根本上避免这种写法。

重写hashcode方法

重写hashcode方法注意事项：

1. 2个对象相等，那么它们的hashcode一定相等，所以参与到equals函数的字段，也必须参与hashcode函数的计算。
2. 最终的hash是个int值，要防止数值溢出。
3. 不同对象的hash码尽量不同，避免hash冲突。

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 31 * hash + age;
        hash = 31 * hash + name.hashCode();
        return hash;
    }

四、Sting类中equals、hashcode方法

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        // 1.根据instance判断运行类
        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;
                // 2.根据每一个元素进行比对
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
}
    
public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;
			// 3. 根据每一个元素计算hash，即`s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]`
            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
}

我们会发现：

1. 在equals方法中，使用了我们上文提倡避免的instance方法，为什么在String类中就可以这样做呢？因为String类是个final类，它是不允许被继承的，所以就不会存在对称性问题。
2. hashcode方法中，计算涉及到的元素，跟equals中涉及到的元素一致的。从而保证了equals相等的元素，hashcode一定相等。

五、HashMap中的equals和hashcode

// put方法
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

// hash的计算方法
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

// 计算数组下标(根据hashcode和数组长度取模，得到数组下标)
i = (n - 1) & hash

// 判断是否相等
// p是HashMap数组中的元素
// key是新加入元素的key， hash是新加入元素的key的hash值
if (p.hash == hash &&  ((k = p.key) == key || (key != null && key.equals(k)))) {
	// 新值替换旧值
}

可以看到hashMap中是根据hashcode和equals来判断元素是否相等，这也是我们要重写这2个方法的原因。