重寫equals的同時為何要重寫hashCode?

結論

先直接上結論:

重寫equals不一定要重寫hashCode,得看情況。如果在沒使用容器時其實是沒必要的。

如果使用瞭HashMap等容器,並且使用瞭自定義對象作為Key是一定要重寫的。

重寫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 +
          '}';
    }
  }

  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), "電腦");
  }
}

總結

到此這篇關於重寫equals的同時為何要重寫hashCode的文章就介紹到這瞭,更多相關重寫equals的同時重寫hashCode內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet!

推薦閱讀: