自定义对象的比较为什么重写equals和hashcode

ゞ浴缸里的玫瑰 2022-05-15 02:52 170阅读 0赞

## 类比String ##

String是我们最常见的一种类型，它同时也很特殊，先不管它的特殊性，我们来看看它的equals方法

1.  String的equals方法  
    ![这里写图片描述][70]  
    其实，我们在调用改方法时，内部就进行对象的引用地址的判断。
2.  String的hashcode方法  
    ![这里写图片描述][70 1]  
    你就会发现，所谓的hash值是计算出来的，因而，hash值是会有冲突的，这种情况很少，也不是没有。我们都知道HashMap中的put(K,V)中的K是唯一的，值可以有多个，如果K的hash值相同，但并不是同一个对象，对hashMap的调用有没有影响呢？

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
     }

上面是jdk的put的源码，你会看到，它调用了另一个方法，我们看看另一个方法：

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

当我们使用put时，会计算键的hash散列值，同时，使用抑或表达式，如图所示：  
![这里写图片描述][ebcf5d17c2707f49fa7859e88cca016d.png]  
由于 h>>>16，高16bit 补0，一个数和0异或不变，所以 hash 函数大概的作用就是：高16bit不变，低16bit和高16bit做了一个异或，目的是减少碰撞。  
为什么会有key==null，因为hashmap允许键为null，补充知识：  
![这里写图片描述][QQ_E6_88_AA_E5_9B_BE20170210121407.png]  
我们来看看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;
        // 初始 tab 为 null，resize 初始化
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 计算下标index，没碰撞，直接放
        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;
                }
            }
            // 节点已存在，替换value
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        // 超过threshold，进行resize扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

--------------------

## 模拟hash冲突。 ##

我们模拟hash冲突

package com.zby.service;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Objects;
    
    /** * @author zhubaoya * @description 学生的实体类 * @time 2018年08月22日 21点14分 * @projectName test */
    @AllArgsConstructor
    @NoArgsConstructor
    @Data
    public class Student { 
    
        private String name;
        private String address;
        private Long id;
    
        @Override
        public int hashCode() {
           return this.hash(name,address,id);
        }
    
        /** * 模拟返回的hash值 * @param obj * @return */
        private int hash(Object...obj){
            if (obj == null) {
                return 0;
            }
            int result=0;
            for (Object o : obj) {
                result = result+1;
            }
            return result;
        }
    }

测试：

@Test
    public void testHash(){
       Student student1=new Student("珠宝亚","安徽省",111L);
       Student student2=new Student("珠宝亚","安徽省",113L);
       System.out.println(student1.hashCode()==student2.hashCode());
    }
    返回结果为ture

通过以上的分析，就感觉到非常危险，因为，我们在做购物车时，使用的是hashMap这个对象。我们通过Key来获取值，如果对象A和对象B的Key的hash值相同。对象A本该取对象A的值，对象B取对象B的值，那么，这时就会出现，对象A不仅取到了本身的值，也取到了对象B的值。同理，对象B也是如此。

当然，模拟毕竟时模拟，而实际上不是这样调用的。接下来，我们就分析为什么重写HashCode和equals方法。

--------------------

## 解析重写的方法 ##

![这里写图片描述][70 2]

1.  首先判断student1和student2的引用地址是否相等，若想等则直接返回，否则执行第二步操作。
2.  假设student2作为参数，判断student2是否为空，为空则直接返回false，不为空执行第三步
3.  通过getClass()获得两个对象的类型，类型相等则执行第四步，否则返回false
4.  判断两个对象的各个属性是否相等，在这里，就用到上面的equals方法。若各个属性的equals方法相等，则直接返回true,只要有一个不等，则返回false  
    ![这里写图片描述][70 3]  
    代码如下：

@Override
    public boolean equals(Object o) {
       if (this == o) {
       return true;}
       if (o == null || getClass() != o.getClass()){ return false;}
       Student student = (Student) o;
       return Objects.equals(name, student.name) &&
                Objects.equals(address, student.address) &&
                Objects.equals(id, student.id);
     }
    
    调用Obejects当中的equals方法：
    public static boolean equals(Object a, Object b) {
            return (a == b) || (a != null && a.equals(b));
    }
    
    调用Object的equals方法
    public boolean equals(Object obj) {
         return (this == obj);
    }

![这里写图片描述][70 4]  
假如student2的id指向 ***0000006X***,这两个对象指定不相等。

--------------------

我们处理student1和student2的hash值。student1的属性name有个hash值，address也有个hash值，id也有个hash值，三个hash值相加得到student1的总的hash1值，同理，student2也有个总的hash2值。如果hash1==hash2，name他们才相等。

1.  student1的name address id的hash值相加得到hash1
2.  student2的name address id的hash值相加得到hash2
3.  判断hash1==hash2  
    代码如下：

@Override
       public int hashCode() {
           return Objects.hash(name, address, id);
       }
    
    调用objects的hash方法：
    public static int hash(Object... values) {
       return Arrays.hashCode(values);
    }
    
    调用Arrays类的hashCode方法
    public static int hashCode(Object a[]) {
            if (a == null)
                return 0;
    
            int result = 1;
    
            for (Object element : a)
                result = 31 * result + (element == null ? 0 : element.hashCode());
    
            return result;
        }

这就是我们为什么重写这两个方法了。

--------------------

***还是多看看JDK的源码，你会受用无穷的***

[70]: /images/20220515/e104b5244178436887328e9fc54cac21.png
[70 1]: /images/20220515/b1c8ce8ebce942508840ad2b4abf9aab.png
[ebcf5d17c2707f49fa7859e88cca016d.png]: /images/20220515/b35624de5e1e42279025edd77a23f71a.png
[QQ_E6_88_AA_E5_9B_BE20170210121407.png]: http://oe9ggtbcb.bkt.clouddn.com/QQ%E6%88%AA%E5%9B%BE20170210121407.png
[70 2]: /images/20220515/5113c67c707d4a27b992a4e122342ac2.png
[70 3]: /images/20220515/571c3d19781e4085b05b1c22f47701e1.png
[70 4]: /images/20220515/76e1a0c2dd9e4a7e9a806de75941f7f5.png

发表评论取消回复

表情：

评论列表（有 0 条评论，170人围观）

还没有评论，来说两句吧...

相关阅读

相关重写equals为什么要重写hashcode

判断两个对象是否相等，我们需要先判断hashcode，在hashcode相等的条件下，再用equals进行比较，equals返回true，两个对象才相等。如果hashcode不

我就是我/ 2024年03月17日 22:48/ 0 赞/ 93 阅读

相关重写equals为什么要重写hashcode

当我们重写一个类的`equals`方法时，通常也需要同时重写`hashCode`方法。这是因为在Java中，`hashCode`方法和`equals`方法是相关联的： 1.

淡淡的烟草味﹌/ 2024年03月17日 21:00/ 0 赞/ 87 阅读

相关 hashCode()和equals()，equals重写为什么一定会重写hashCode()方法？

![183630813d074c539beba2591aeb1193.png][] 一、Java 的 hashCode 方法 hashCode是Java中Object类

柔光的暖阳◎/ 2024年03月16日 12:55/ 0 赞/ 56 阅读

相关 HashMap添加的对象为什么要重写equals()和hashcode()

1. 首先要了解原生的Object类的hashCode和equals是什么样？ public native int hashCode(); pub

小灰灰/ 2023年10月09日 09:41/ 0 赞/ 27 阅读

相关究竟为什么要重写equals和hashcode

1、equals()方法和hashCode()方法介绍 `equals()`方法和`hashCode()`方法都是根类Obeject中的方法。 1.1、equals(

太过爱你忘了你带给我的痛/ 2023年06月14日 10:47/ 0 赞/ 51 阅读

相关为什么HashCode和equals要一起重写

有句话是equals和hashcode必须同时重写。那么为啥嘞？其实是分场景的，想一下HashMap，我们在put的时候的流程 1. 对key进行hash，确定k

╰+攻爆jí腚メ/ 2023年06月12日 09:18/ 0 赞/ 7 阅读

相关自定义对象的比较为什么重写equals和hashcode

类比String String是我们最常见的一种类型，它同时也很特殊，先不管它的特殊性，我们来看看它的equals方法 1. String的equals方法

ゞ浴缸里的玫瑰/ 2022年05月15日 02:52/ 0 赞/ 171 阅读

相关为什么要重写 hashcode 和 equals 方法？

我在面试Java初级开发的时候，经常会问：你有没有重写过hashcode方法？不少候选人直接说没写过。我就想，或许真的没写过，于是就再通过一个问题确认：你在用HashMap的时

骑猪看日落/ 2022年02月24日 04:30/ 0 赞/ 364 阅读

相关为什么要重写hashcode和equals方法？

摘要: 原创出处 [cnblogs.com/JavaArchitect/p/10474448.html][cnblogs.com_JavaArchitect_p_1047444

旧城等待，/ 2022年01月10日 08:07/ 0 赞/ 327 阅读

相关自定义对象为什么要重写hashcode()和equals()方法？

1.hashcode()和equals()方法是用于自定义比较两个对象是否是同一个对象的。 2.当把自定义对象添加到去重集合时，如hashset，hashset会先调用has

短命女/ 2021年11月22日 09:34/ 0 赞/ 336 阅读