一、hashCode()方法

hashCode() 方法：
(1) 作用：用于判斷兩個(gè)對(duì)象是否相等；
(2) 實(shí)現(xiàn)：通過(guò)獲取到的哈希碼來(lái)確定該對(duì)象在哈希表中的索引位置，哈希碼也稱(chēng)散列碼，實(shí)際上就是返回一個(gè)int整數(shù)；
(3) Object類(lèi)：hashCode() 定義在JDK的Object.java中，這就意味著Java中的任何類(lèi)都包含有hashCode() 函數(shù)，并且通過(guò)調(diào)用hashCode()方法獲取對(duì)象的hash值。

舉個(gè)例子

public class DemoTest {​
    public static void main(String[] args) {
        Object obj = new Object();
        System.out.println(obj.hashCode());
    }
}

這段代碼中，obj引用就是通過(guò)調(diào)用hashCode()方法來(lái)獲取對(duì)象的hash值。

二、equals()方法

equals()方法：
(1) 作用：用于判斷兩個(gè)對(duì)象是否相等；
(2) 實(shí)現(xiàn)：如果對(duì)象重寫(xiě)了equals()方法，重寫(xiě)的比較邏輯一般是比較兩個(gè)對(duì)象的內(nèi)容是否相等；如果沒(méi)有重寫(xiě)，那就是比較兩個(gè)對(duì)象的地址是否相同，等價(jià)于“==”；
(3) Object類(lèi)：equals()定義在JDK的Object.java中，這就意味著Java中的任何類(lèi)都包含有equals()函數(shù)，并且通過(guò)調(diào)用equals()方法比較兩個(gè)引用相等，引用復(fù)制就相等，淺復(fù)制和深復(fù)制都不相等。

舉個(gè)例子

public class DemoTest {​
    public static void main(String[] args) {
        Object obj = new Object();
        System.out.println(obj.equals(obj));
    }
}

這段代碼中，obj引用就是通過(guò)調(diào)用equals()方法來(lái)比較對(duì)象引用的。

三、hashCode() 與 equals()

接下面，我們討論另外一個(gè)話題——hashCode() 和 equals() 這兩個(gè)方法有什么關(guān)系？為什么重寫(xiě)equals就要重寫(xiě)hashcode?

3.1 不會(huì)創(chuàng)建“類(lèi)對(duì)應(yīng)的散列表”的情況

不會(huì)創(chuàng)建“類(lèi)對(duì)應(yīng)的散列表”的情況下，
(1) hashCode()：hashCode()除了打印引用所指向的對(duì)象地址看一看，沒(méi)有任何調(diào)用，重寫(xiě)hashCode()邏輯也沒(méi)有用，反正沒(méi)有調(diào)用；
(2) equals()：equals()用來(lái)比較，可以自定義比較邏輯；
(3) 關(guān)系：hashCode()和equals()是兩個(gè)獨(dú)立方法，沒(méi)有任何關(guān)系，所以不存在重寫(xiě)equals()要重寫(xiě)hashCode()。

這里所說(shuō)的“不會(huì)創(chuàng)建類(lèi)對(duì)應(yīng)的散列表”是說(shuō)：我們不會(huì)在HashSet, HashTable, HashMap等這些本質(zhì)是散列表的數(shù)據(jù)結(jié)構(gòu)中使用該類(lèi)作為泛型。在這種情況下，該類(lèi)的“hashCode() 和 equals() ”沒(méi)有半毛錢(qián)關(guān)系。

小結(jié)：當(dāng)我們不在HashSet, HashTable, HashMap等等這些本質(zhì)是散列表的數(shù)據(jù)結(jié)構(gòu)中用到這個(gè)類(lèi)，此時(shí)，equals() 用來(lái)比較該類(lèi)的兩個(gè)對(duì)象是否相等，而hashCode() 則根本沒(méi)有任何作用，所以，不用理會(huì)hashCode()。

舉個(gè)例子

class Main2cumtomzieEquals {
    public static void main(String[] args) {
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        Person p3 = new Person("aaa", 200);
        System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
        System.out.printf("p1.equals(p3) : %s; p1(%d) p3(%d)\n", p1.equals(p3), p1.hashCode(), p3.hashCode());
    }

    private static class Person {
        private String name;
        private int age;

        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
        
        /**
         * 重寫(xiě)equals方法
         */
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }

            // 如果是同一個(gè)對(duì)象返回true，反之返回false
            if (this == obj) {
                return true;   // 引用相同，返回為true
            }
            
            // 判斷是否類(lèi)型相同
            if (this.getClass() != obj.getClass()) {
                return false;   // getClass() 不相同，為false
            }
            Person person = (Person) obj;  // 引用賦值
            return name.equals(person.name) && age == person.age;   // name引用相同 && age引用相同
        }
    }
}

運(yùn)行結(jié)果：

p1.equals(p2) : true; p1(2133927002) p2(1836019240)
p1.equals(p3) : false; p1(2133927002) p3(1625635731)

這段程序證明：對(duì)于當(dāng)我們不在HashSet, HashTable, HashMap等等這些本質(zhì)是散列表的數(shù)據(jù)結(jié)構(gòu)中用到這個(gè)類(lèi)作為泛型，此時(shí)，這個(gè)類(lèi)的hashCode() 和 equals()沒(méi)有任何關(guān)系，在p1和p2使用equals()比較相等的情況下，hashCode()也不一定相等。

小結(jié)：不會(huì)創(chuàng)建“類(lèi)對(duì)應(yīng)的散列表”的情況下，
對(duì)于hashCode()：默認(rèn)hashCode()僅僅返回一個(gè)int型哈希值，但是這個(gè)返回的哈希值沒(méi)卵用；
對(duì)于equals()：默認(rèn)的equals)比較兩個(gè)引用是否相等，而我們自己重寫(xiě)的equals用來(lái)比較兩類(lèi)的屬性是否相等，因?yàn)橐觅x值，所有最后兩個(gè)屬性int string一定是一樣的

Person person = (Person) obj; // 引用賦值
return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同

3.2 會(huì)創(chuàng)建“類(lèi)對(duì)應(yīng)的散列表”的情況

不會(huì)創(chuàng)建“類(lèi)對(duì)應(yīng)的散列表”的情況下，該類(lèi)的“hashCode() 和 equals() ”是有關(guān)系的:

(1) 如果兩個(gè)對(duì)象相等，那么它們的hashCode()值一定相同。這里的“對(duì)象相等”是指通過(guò)equals()比較兩個(gè)對(duì)象時(shí)返回true。

(2) 如果兩個(gè)對(duì)象hashCode()相等，它們的equals()不一定相等。因?yàn)樵谏⒘斜碇?，hashCode()相等，即兩個(gè)鍵值對(duì)的哈希值相等，然而哈希值相等，并不一定能得出鍵值對(duì)相等，此時(shí)就出現(xiàn)所謂的哈希沖突場(chǎng)景。

這里所說(shuō)的“會(huì)創(chuàng)建類(lèi)對(duì)應(yīng)的散列表”是說(shuō)：我們會(huì)在HashSet, HashTable, HashMap等等這些本質(zhì)是散列表的數(shù)據(jù)結(jié)構(gòu)中用到該類(lèi)。

3.2.1 Set無(wú)法去重問(wèn)題

自定義類(lèi)作為HashSet的泛型，自定義類(lèi)重寫(xiě)equals()不重寫(xiě)hashCode()，equals()的return true的范圍比hashCode() return 哈希值范圍大，導(dǎo)致HashSet中中出現(xiàn)重復(fù)元素，舉個(gè)例子，如下：

import java.util.HashSet;

class Main3cumtomizeEquals {
    public static void main(String[] args) {
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        Person p3 = new Person("aaa", 200);
        // 新建HashSet對(duì)象
        HashSet<Person> 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);
    }

    private static class Person {
        private String name;
        private int age;

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

        /**
         * 重寫(xiě)equals方法,當(dāng)其 name引用相同 && age引用相同 的時(shí)候就認(rèn)為它相同，
         */
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }

            // 如果是同一個(gè)對(duì)象返回true，反之返回false
            if (this == obj) {
                return true;   // 引用相同，返回為true
            }
            
            // 判斷是否類(lèi)型相同
            if (this.getClass() != obj.getClass()) {
                return false;   // getClass() 不相同，為false
            }
            Person person = (Person) obj;  // 引用賦值
            return name.equals(person.name) && age == person.age;   // name引用相同 && age引用相同
        }
    }
}

運(yùn)行結(jié)果：

p1.equals(p2) : true; p1(2133927002) p2(1836019240)
set:[package1.Main3cumtomizeEquals$Person@6d6f6e28, package1.Main3cumtomizeEquals$Person@7f31245a, package1.Main3cumtomizeEquals$Person@135fbaa4]

結(jié)果分析：

問(wèn)題：上面的程序中，重寫(xiě)了Person的equals()，但是，HashSet中仍然有重復(fù)元素：p1 和 p2。為什么會(huì)出現(xiàn)這種情況呢？

回答：因?yàn)殡m然p1 和 p2的內(nèi)容相等，但是它們的hashCode()不等，所以，HashSet在添加p1和p2的時(shí)候，認(rèn)為它們不相等，從而導(dǎo)致存儲(chǔ)HashSet存儲(chǔ)重復(fù)元素。

3.2.2 哈希沖突問(wèn)題

自定義類(lèi)作為HashSet的泛型，自定義類(lèi)重寫(xiě)equals()并重寫(xiě)hashCode()，hashCode() return 哈希值范圍比equals() return true范圍大，造成哈希沖突，舉個(gè)例子，如下：

import java.util.HashSet;

class Main4cumtomizeEqualsAndhashcode {

    public static void main(String[] args) {
        // 新建Person對(duì)象
        Person p1 = new Person("eee", 100);
        Person p2 = new Person("eee", 100);
        Person p3 = new Person("aaa", 200);
        Person p4 = new Person("EEE", 100);
        // 新建HashSet對(duì)象
        HashSet<Person> set = new HashSet<>();
        set.add(p1);
        set.add(p2);
        set.add(p3);
        set.add(p4);
        // 比較p1 和 p2， 并打印它們的hashCode()
        System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());
        // 比較p1 和 p4， 并打印它們的hashCode()
        System.out.printf("p1.equals(p4) : %s; p1(%d) p4(%d)\n", p1.equals(p4), p1.hashCode(), p4.hashCode());
        // 打印set
        System.out.printf("set:%s\n", set);
    }


    private static class Person {
        private String name;
        private int age;

        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
        
        /**
         * 重寫(xiě)equals方法,當(dāng)其 name引用相同 && age引用相同 的時(shí)候就認(rèn)為它相同
         */
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }

            // 如果是同一個(gè)對(duì)象返回true，反之返回false
            if (this == obj) {
                return true;   // 引用相同，返回為true
            }
            
            // 判斷是否類(lèi)型相同
            if (this.getClass() != obj.getClass()) {
                return false;   // getClass() 不相同，為false
            }
            Person person = (Person) obj;  // 引用賦值
            return name.equals(person.name) && age == person.age;   // name引用相同 && age引用相同
        }
        
        /**
         * 重寫(xiě)hashCode方法,邏輯為  name的哈希值^age
         */
        @Override
        public int hashCode() {
            // 68517 ^ 100 = 68545
            // 64545 ^ 200 =68545
            // 68517 ^ 100 =68545
            int nameHash = name.toUpperCase().hashCode();
            return nameHash ^ age;   //  ^  異或運(yùn)算，相同為0，不同為1
        }
    }
}

運(yùn)行結(jié)果：

p1.equals(p2) : true; p1(68545) p2(68545)   //
p1.equals(p4) : false; p1(68545) p4(68545)   //  hashcode相等，equals不相等，這樣還是不好
set:[package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@fce9]

結(jié)果分析：上面程序中，重寫(xiě)hashCode()的同時(shí)重寫(xiě)了equals()，equals()生效了，HashSet中沒(méi)有重復(fù)元素。

因?yàn)樵贖ashSet比較p1和p2時(shí)，HashSet會(huì)發(fā)現(xiàn)，它們的hashCode()相等，通過(guò)equals()比較它們也返回true，所以，HashSet將p1和p2被視為相等，不會(huì)存儲(chǔ)多份。 同樣地，在比較p1和p4時(shí)，HashSet發(fā)現(xiàn)：雖然它們的hashCode()相等，但是通過(guò)equals()比較它們返回false，所以，HashSet將p1和p4被視為不相等，p1和p4各存儲(chǔ)一份。

3.2.3 equals()和hashCode()完全對(duì)應(yīng)

上面代碼好的修改方法（讓equals和hashcode完全對(duì)應(yīng)）：

/**
 * 重寫(xiě)equals方法,當(dāng)其 name引用相同 && age引用相同 的時(shí)候就認(rèn)為它相同，
 */
@Override
public boolean equals(Object obj) {
    if (obj == null) {
        return false;
    }

    // 如果是同一個(gè)對(duì)象返回true，反之返回false
    if (this == obj) {
        return true;   // 引用相同，返回為true
    }

    // 判斷是否類(lèi)型相同
    if (this.getClass() != obj.getClass()) {
        return false;   // getClass() 不相同，為false
    }
    Person person = (Person) obj;  // 引用賦值
    return name.equals(person.name) && age == person.age;   // name引用相同 && age引用相同
}

/**
 * 重寫(xiě)hashCode方法,邏輯為  name的哈希值^age
 */
@Override
public int hashCode() {
    int nameHash = name.hashCode();
    return nameHash ^ age;   //  ^  異或運(yùn)算，相同為0，不同為1
}

最后返回

p1.equals(p2) : true; p1(68545) p2(68545)   //  hashcode相等，equals相等
p1.equals(p4) : false; p1(68545) p4(68548)   //  hashcode不相等，equals不相等
set:[package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@fce9]

3.2.4 進(jìn)一步解釋為什么重寫(xiě)equals()就要重寫(xiě)hashCode()

/**
 * HashSet部分
 */
public boolean add (E e){
    return map.put(e, PRESENT) == null;
}​​

/**
 * map.put方法部分
 */
public V put (K key, V value){
    return putVal(hash(key), key, value, false, true);
}​

/**
 * putVal方法部分
 */
final V putVal ( int hash, K key, V value,boolean onlyIfAbsent, boolean evict){
    Node<K, V>[] tab;
    Node<K, V> p;
    int n, i;
    if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null);
    else {
        Node<K, V> e;
        K k;
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p;
        else if (p instanceof TreeNode) e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break;
                p = e;
            }
        }
        if (e != null) {
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null) e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold) resize();
    afterNodeInsertion(evict);
    return null;
}

由上面HashSet源碼可知，HashSet使用的是HashMap的put方法，而hashMap的put方法，使用hashCode()用key作為參數(shù)計(jì)算出hash值，然后進(jìn)行比較，如果相同，再通過(guò)equals()比較key值是否相同，如果相同，返回同一個(gè)對(duì)象。

所以，如果類(lèi)使用再散列表的集合對(duì)象中，要判斷兩個(gè)對(duì)象是否相同，除了要覆蓋equals()之外，也要覆蓋hashCode()函數(shù)，否則，equals()無(wú)效。

所以，在HashSet中，一定要同時(shí)重寫(xiě)hashCode()和equals()，HashSet底層是由于HashMap的數(shù)據(jù)結(jié)構(gòu)（數(shù)組+鏈表/紅黑樹(shù)）的比較邏輯決定的。

四、重寫(xiě)hashCode()的目標(biāo)

理論上，一個(gè)好的hashCode的方法的目標(biāo)：為不相等的對(duì)象（equals為false）產(chǎn)生不相等的散列碼，而相等的對(duì)象（equals為true）必須擁有相等的散列碼。

即equals和hashcode對(duì)應(yīng)，向默認(rèn)的那樣，既不會(huì)出現(xiàn)hashcode相等，equals不相等的哈希沖突，也不會(huì)出現(xiàn)equals相等，hashcode不相等造成HashSet存放equals為true的元素。

實(shí)際上，一般來(lái)說(shuō)，hashcode相等，equals不相等的哈希沖突還能忍受，但是equals相等造成hashcode不相等，造成HashSet存放相同是一定不能忍受的，就是說(shuō)，重寫(xiě)equals放寬return true的同時(shí)一定要重寫(xiě)hashcode放寬return 哈希碼。

以下驗(yàn)證本文中心問(wèn)題：

(1) 把某個(gè)非零的常數(shù)值，比如17，保存在一個(gè)int型的result中。

(2) 對(duì)于每個(gè)關(guān)鍵域f（equals方法中設(shè)計(jì)到的每個(gè)域），為該域計(jì)算int類(lèi)型的散列碼，并

① 如果該域是boolean類(lèi)型，則計(jì)算(f?1:0)；
② 如果該域是byte,char,short或者int類(lèi)型,計(jì)算(int)f；
③ 如果是long類(lèi)型，計(jì)算(int)(f^(f>>>32))；
④ 如果是float類(lèi)型，計(jì)算Float.floatToIntBits(f)；
⑤ 如果是double類(lèi)型，計(jì)算Double.doubleToLongBits(f),然后再計(jì)算long型的hash值；
⑥ 如果是對(duì)象引用，則遞歸的調(diào)用域的hashCode，如果是更復(fù)雜的比較，則需要為這個(gè)域計(jì)算一個(gè)范式，然后針對(duì)范式調(diào)用hashCode，如果為null，返回0；
⑦ 如果是一個(gè)數(shù)組，則把每一個(gè)元素當(dāng)成一個(gè)單獨(dú)的域來(lái)處理。

(3) 執(zhí)行result = 31 * result + name.hashcode()，并返回result。

(4) 編寫(xiě)單元測(cè)試驗(yàn)證有沒(méi)有實(shí)現(xiàn)所有相等的實(shí)例都有相等的散列碼。

給個(gè)簡(jiǎn)單的例子（一個(gè)好的hashCode()的使用）：

@Overridepublic int hashCode() {
    int result = 17; 
    result = 31 * result + name.hashCode(); 
    return result;
}

這里再說(shuō)下2.b中為什么采用31*result + c,乘法使hash值依賴(lài)于域的順序，如果沒(méi)有乘法那么所有順序不同的字符串String對(duì)象都會(huì)有一樣的hash值，而31是一個(gè)奇素?cái)?shù)，如果是偶數(shù)，并且乘法溢出的話，信息會(huì)丟失，31有個(gè)很好的特性是31*i ==(i<<5)-i,即2的5次方減1，虛擬機(jī)會(huì)優(yōu)化乘法操作為移位操作的。

五、面試金手指

5.1 為什么重寫(xiě)equals()一定要重寫(xiě)hashCode()

5.1.1 不會(huì)創(chuàng)建“類(lèi)對(duì)應(yīng)的散列表”的情況

當(dāng)我們不在HashSet, HashTable, HashMap等這些本質(zhì)是散列表的數(shù)據(jù)結(jié)構(gòu)中，用到這個(gè)類(lèi)作為泛型，此時(shí)，這個(gè)類(lèi)的hashCode() 和 equals()沒(méi)有任何關(guān)系；

equals()方法
(1) 作用： equals() 用來(lái)比較該類(lèi)的兩個(gè)對(duì)象是否相等。
(2) 實(shí)現(xiàn)：equals未被重寫(xiě)就直接進(jìn)行引用比較，源碼如下：

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

若equals已被重寫(xiě)，就按照自己的重寫(xiě)equals邏輯來(lái)。

hashCode()：默認(rèn)的hashcode()就是返回哈希值，但是此時(shí)返回的哈希值根本沒(méi)有任何作用，不用理會(huì)hashCode()。

當(dāng)我們不在HashSet, HashTable, HashMap等等這些本質(zhì)是散列表的數(shù)據(jù)結(jié)構(gòu)中，用到這個(gè)類(lèi)作為泛型，這種情況下，

(1) 不重寫(xiě)equals，不重寫(xiě)hashCode()
equals直接比較引用，hashCode()也是直接返回對(duì)象地址， 所以，equals()與hashCode()完全對(duì)應(yīng)，即對(duì)于兩個(gè)引用：
① equals為true，hashCode()一定相等；
② equals為false，hashCode()一定不相等；
③ hashCode()相等，equals一定為true；
④ hashCode()不相等，equals一定為false。

(2) 重寫(xiě)equals()為比較對(duì)象的屬性，不重寫(xiě)hashCode()
① 如果equals()相等，表示兩個(gè)引用相等或兩個(gè)引用指向的對(duì)象各個(gè)屬性(基本類(lèi)型+String)相等，hashcode()不一定相等（理由：因?yàn)橐欢ㄒ獌蓚€(gè)引用相等，指向的對(duì)象地址才相等）。
② 如果hashCode()相等，表示兩個(gè)引用指向的對(duì)象哈希地址相等，則引用相等（因?yàn)楣?duì)象哈希地址是任意分配的），equals()一定相等（未重寫(xiě)比較引用相等，已重寫(xiě)）。
③ 如果equals不相等，表示兩個(gè)引用一定不相等，hashcode()兩個(gè)引用所指向的對(duì)象地址一定不相等（因?yàn)楣５刂冯S機(jī)分配）。
④ 如果hashcode不相等，兩個(gè)引用指向的對(duì)象地址不相等，equals()可以相等，可以不相等。

小結(jié)：不能說(shuō)明equals()和hashCode()有關(guān)系，只是因?yàn)橹貙?xiě)equals()把return true;的條件放寬了，只要兩個(gè)引用指向的對(duì)象中屬性相等就好，不一定引用相等，但是hashCode()還是返回對(duì)象地址。

5.1.2 創(chuàng)建“類(lèi)對(duì)應(yīng)的散列表”的情況下

當(dāng)我們?cè)贖ashSet, HashTable, HashMap等等這些本質(zhì)是散列表的數(shù)據(jù)結(jié)構(gòu)中，用到這個(gè)類(lèi)，就是這個(gè)類(lèi)作為集合框架的泛型，此時(shí)，這個(gè)類(lèi)的hashCode() 和 equals()緊密相關(guān)；因?yàn)檫@些散列表數(shù)據(jù)結(jié)構(gòu)，對(duì)其泛型，要求兩個(gè)引用所指向的對(duì)象hashCode() 和 equals()均相同，才認(rèn)為是同一個(gè)對(duì)象。

(1) 重寫(xiě)equals()為比較對(duì)象的屬性，不重寫(xiě)hashCode()

equals()相等，hashcode()可以不相等：HashSet中放入兩個(gè)相同就有相同屬性的Person對(duì)象，兩個(gè)Person對(duì)象屬性相同，所以equals比較兩個(gè)引用得到的結(jié)果相等，但是底層指向不同的對(duì)象地址，因此hashcode不相等，則HashSet在添加p1和p2的時(shí)候認(rèn)為它們不相等，所以，HashSet中仍然有重復(fù)元素：p1 和 p2。

這說(shuō)明默認(rèn)的hashcode()不夠好，一個(gè)好的哈希算法不應(yīng)該讓HashSet中有重復(fù)元素。因?yàn)橐獙?duì)應(yīng)equals()的判斷為true要和hashCode()的判斷完全對(duì)應(yīng)，默認(rèn)的equals()和hashCode()就是比較引用和對(duì)象地址的，我們重寫(xiě)的equals()和hashCode()，是比較引用所指向的對(duì)象的個(gè)數(shù)屬性的，總之，equals()和hashCode()要一一對(duì)應(yīng)，所以重寫(xiě)equals()就要重寫(xiě)hashCode()。

(2) 重寫(xiě)equals為比較對(duì)象的屬性，并且重寫(xiě)hashCode()

重寫(xiě)的equals()：兩個(gè)引用相等或者兩個(gè)引用所指向的對(duì)象的屬性相等，返回true，其余返回為false。
重寫(xiě)的hashCode()： name的哈希值^age，異或運(yùn)算，相同為0，不同為1。

重寫(xiě)equals并且重寫(xiě)hashCode()，三種情況如下：
① equals相等，hashcode()不相等：HashSet集合中的內(nèi)容相同的元素(這就是重寫(xiě)equals不重寫(xiě)hashcode帶來(lái)的問(wèn)題);
② equals相等，hashcode()相等：完全對(duì)應(yīng);
③ hashCode()相等，equals不相等：HashMap中的哈希沖突.

在完全對(duì)應(yīng)的情況下，在HashSet看來(lái)：比較p1和p2，它們的hashCode()相等，通過(guò)equals()比較它們也返回true，所以p1和p2被視為相等；比較p1和p4，雖然它們的hashCode()相等；但是，通過(guò)equals()比較它們返回false，p1和p4被視為不相等。

小結(jié)：

(1) 不會(huì)創(chuàng)建“類(lèi)對(duì)應(yīng)的散列表”，hashcode除了打印引用所指向的對(duì)象地址看一看，沒(méi)有任何調(diào)用，重寫(xiě)hashcode邏輯也沒(méi)有用，反正沒(méi)有調(diào)用，equals用來(lái)比較，可以自定義比較邏輯，hashcode和equals是兩個(gè)獨(dú)立方法，沒(méi)有任何關(guān)系，不存在重寫(xiě)equals要重寫(xiě)hashcode。
(2) 當(dāng)我們?cè)贖ashSet, HashTable, HashMap等等這些本質(zhì)是散列表的數(shù)據(jù)結(jié)構(gòu)中，用到這個(gè)類(lèi)，就是這個(gè)類(lèi)作為集合框架的泛型，此時(shí)，這個(gè)類(lèi)的hashCode() 和 equals()緊密相關(guān)，因?yàn)檫@些散列表數(shù)據(jù)結(jié)構(gòu)，對(duì)其泛型，要求兩個(gè)引用所指向的對(duì)象hashCode() 和 equals()均相同，才認(rèn)為是同一個(gè)對(duì)象。

5.2 hashCode()底層實(shí)現(xiàn)，一個(gè)好的哈希算法

理論上，一個(gè)好的hashCode的方法的目標(biāo)：為不相等的對(duì)象（equals為false）產(chǎn)生不相等的散列碼，同樣的，相等的對(duì)象（equals為true）必須擁有相等的散列碼，即equals和hashcode對(duì)應(yīng)，向默認(rèn)的那樣，既不會(huì)出現(xiàn)hashcode相等，equals不相等的哈希沖突，也不會(huì)出現(xiàn)equals相等，hashcode不相等造成HashSet存放equals為true的元素。

實(shí)踐上，一般來(lái)說(shuō)，hashcode相等，equals不相等的哈希沖突還能忍受，但是equals相等造成hashcode不相等，造成HashSet存放相同是一定不能忍受的，就是說(shuō)，重寫(xiě)equals放寬return true;一定要重寫(xiě)hashcode放寬return 哈希碼，驗(yàn)證本文中心問(wèn)題，一定要hashcode范圍和equals范圍一樣大，不能保證的化，就讓hashcode范圍比equals范圍大，允許哈希沖突不允許HashSet存放重復(fù)元素。

六、尾聲

為什么重寫(xiě)equals()就要重寫(xiě)hashCode()，完成了。

源代碼工程地址：hashcode-equals_jb51.rar

到此這篇關(guān)于淺談為什么重寫(xiě)equals()就要重寫(xiě)hashCode()的文章就介紹到這了,更多相關(guān)重寫(xiě)equals()就要重寫(xiě)hashCode()內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論