java重寫equals時為什麼還要重寫hashcode？
- 王林轉載
- 2021-01-08 10:22:332699瀏覽
先把結論告訴大家：
我們要先明確一點，重寫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 +
'}';
}
}
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中文網其他相關文章！