为什么重写equals同时要重写hashCode?

更新时间:2021-01-11 14:28:27 点击次数:211次
当使用自定义类作为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), "电脑");
    }
}

本站文章版权归原作者及原出处所有 。内容为作者个人观点, 并不代表本站赞同其观点和对其真实性负责,本站只提供参考并不构成任何投资及应用建议。本站是一个个人学习交流的平台,网站上部分文章为转载,并不用于任何商业目的,我们已经尽可能的对作者和来源进行了通告,但是能力有限或疏忽,造成漏登,请及时联系我们,我们将根据著作权人的要求,立即更正或者删除有关内容。本站拥有对此声明的最终解释权。

回到顶部
嘿,我来帮您!