首頁 > Java > Java入門 > 主體

java重寫equals時為什麼還要重寫hashcode?

王林
發布: 2021-01-08 10:22:33
轉載
2717 人瀏覽過

java重寫equals時為什麼還要重寫hashcode?

先把結論告訴大家:

我們要先明確一點,重寫equals不一定要hashcode,這要看實際狀況。例如在沒使用容器時其實是沒必要的,但是如果使用了HashMap等容器,並且使用了自訂物件作為Key是一定要重寫的。

(學習影片分享:java影片教學

重寫equals是為了在業務邏輯上判斷實例之間是否相等。重寫hascode是為了讓集合快速判重。

hashCode()與equals() 的規定:

1.如果兩個物件相等,則hashcode 一定也是相同的
2.兩個物件相等,對兩個equals () 方法傳回true
3.兩個物件有相同的hashcode 值,它們也不一定是相等的
4.綜上,equals() 方法被覆寫過,則hashCode() 方法也必須被覆寫
5.hashCode() 的預設行為是對堆上的物件產生獨特值。如果沒有重寫 hashCode(),則該 class 的兩個物件無論如何都不會相等(即使這兩個物件指向相同的資料)。

下面舉個例子說明一定要重寫。

當使用自訂類別作為HashMap的Key時put時

如果只重寫equals不重寫hashCode會出現邏輯錯誤

先看下面的程式碼

public class Test {

    static class Order {
    
        private Long orderId;

        public Order(Long orderId) {
            this.orderId = orderId;
        }

        public Long getOrderId() {
            return orderId;
        }

        public void setOrderId(Long orderId) {
            this.orderId = orderId;
        }

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

            return Objects.equals(this.orderId, ((Order) obj).orderId);
        }

        @Override
        public String toString() {
            return "Order{" +
                    "orderId=" + orderId +
                    '}';
        }
    }

    public static void main(String[] args) {
        Map<Order, String> map = new HashMap<>();

        Order order1 = new Order(1000000001L);
        Order order2 = new Order(1000000001L);

        map.put(order1, "");
        map.put(order2, "");

        System.out.println(map);
    }
}
登入後複製

運行輸出:

{Order{orderId=1000000001}=, Order{orderId=1000000001}=}
登入後複製

在程式碼中重寫了equals方法,沒重寫hashCode方法。
equals重寫的邏輯是:只要orderId相等那麼這兩個物件就相等。
而從運行結果來看,兩個orderId一致的物件都成功put到了map中。這就是邏輯錯誤了,因為按照邏輯來說期望的結果應該只有一個Order在map才對。
我們來看下HashMap的原始碼
只需要看寫了註解的那個判斷

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
     int h;
     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
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;
    // 通过hash算出索引  通过索引取值==null的话  直接直接插入到索引位置。
    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) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}
登入後複製

透過原始碼我們知道,只要hash碼不一樣的話就可以直接插入到陣列中。然而正因為我們沒重寫hashCode方法,所以呼叫的是Object的hashCode方法。而Object的hashCode是使用物件在堆中的位址透過演算法得出一個int類型的值,既然如此,那麼剛剛建立的兩個物件的int類型的值肯定是不同的,所以兩個Order都可以正常插入到數組中,從而出現了邏輯錯誤。

重寫hashCode方法:

public class TestHash {

    static class Order {


        private Long orderId;

        public Order(Long orderId) {
            this.orderId = orderId;
        }

        public Long getOrderId() {
            return orderId;
        }

        public void setOrderId(Long orderId) {
            this.orderId = orderId;
        }

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

            return Objects.equals(this.orderId, ((Order) obj).orderId);
        }

        @Override
        public int hashCode() {
        	// 这里简单重写下   实际开发根据自己需求重写即可。
            return this.orderId.intValue() >> 2;
        }

        @Override
        public String toString() {
            return "Order{" +
                    "orderId=" + orderId +
                    &#39;}&#39;;
        }
    }

    public static void main(String[] args) {
        Map<Order, String> map = new HashMap<>();

        Order order1 = new Order(1000000001L);
        Order order2 = new Order(1000000001L);

        map.put(order1, "");
        map.put(order2, "");

        System.out.println(map);
    }
}
登入後複製

再次運行輸出:

{Order{orderId=1000000001}=}
登入後複製

我們簡單看下原始碼(為了好理解,我只截取了重點程式碼):以put order2作為註釋講解。

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;
    // 重写hashCode之后两个对象的orderId相同,hashCode也肯定相同。
    // 通过hash算出索引  通过索引取值  有值不进入if。
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 由于重写了hashCode  旧对象的hashCode和新的肯定相等
        if (p.hash == hash &&
        // (k = p.key) == key == false 因为比较的是对象地址
        // (key != null && key.equals(k)) == true 因为重写了equals orderId相等则相等 
            ((k = p.key) == key || (key != null && key.equals(k))))
            // 保存旧Node
            e = p;
        .......
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
            	// value覆盖旧Node的值
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
   ........
}
登入後複製

所以order2覆蓋了order1。這就是為什麼當使用自訂物件作為HashMap的Key時如果重寫了equals要同時hashCode。

反過來說:重寫了hashCode,equals需要重寫嗎?

答案是要的,都要重寫!

還是以上面程式碼重寫的邏輯為例,假設hashCode相同的兩個對象,且已經put order1在put時,hash相同,得出的索引也是相同,就可以取到order1,取到之後會繼續使用equals比較,假設沒有重寫的話,那麼就是物件位址比較,結果肯定是false,那麼這個時候就發生了hash碰撞,也就形成了鍊錶。

還有在map.get(key)時也是一樣都會根據hashCode找,再判斷equals。
為什麼要判斷equals呢?因為根據hashCode找到的是一個鍊錶,需要根據equals在鍊錶中找到Key相等的那個值。

什麼場景會用到自訂類別做key?

最常見的key是一個座標,比如說在地圖的某個座標放置一個物件之類的。

public class Test {

    static class Coordinate {
        public Coordinate(int x, int y) {
            this.x = x;
            this.y = y;
        }

        private int x;
        private int y;

        public int getX() {
            return x;
        }

        public void setX(int x) {
            this.x = x;
        }

        public int getY() {
            return y;
        }

        public void setY(int y) {
            this.y = y;
        }
    }

    public static void main(String[] args) {
        Map<Coordinate, String> map = new HashMap<>();
        map.put(new Coordinate(22, 99), "手机");
        map.put(new Coordinate(44, 48), "电脑");
    }
}
登入後複製

相關推薦:java入門教學

以上是java重寫equals時為什麼還要重寫hashcode?的詳細內容。更多資訊請關注PHP中文網其他相關文章!

相關標籤:
來源:csdn.net
本網站聲明
本文內容由網友自願投稿,版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容,請聯絡admin@php.cn
熱門教學
更多>
最新下載
更多>
網站特效
網站源碼
網站素材
前端模板