重写hashcode和equals方法

我们都知道，要比较两个对象是否相等时需要调用对象的equals()方法，即判断对象引用所指向的对象地址是否相等，对象地址相等时，那么与对象相关的对象句柄、对象头、对象实例数据、对象类型数据等也是完全一致的，所以我们可以通过比较对象的地址来判断是否相等。

二。Object源码理解

对象在不重写的情况下使用的是Object的equals方法和hashcode方法，从Object类的源码我们知道，默认的equals 判断的是两个对象的引用指向的是不是同一个对象；而hashcode也是根据对象地址生成一个整数数值；

另外我们可以看到Object的hashcode()方法的修饰符为native,表明该方法是否操作系统实现，java调用操作系统底层代码获取哈希值。

三。需要重写equals()的场景

假设现在有很多学生对象，默认情况下，要判断多个学生对象是否相等，需要根据地址判断，若对象地址相等，那么对象的实例数据一定是一样的，但现在我们规定：当学生的姓名、年龄、性别相等时，认为学生对象是相等的，不一定需要对象地址完全相同，例如学生A对象所在地址为100，学生A的个人信息为（姓名：A,性别:女，年龄：18，住址：北京软件路999号，体重：48），学生A对象所在地址为388，学生A的个人信息为（姓名：A,性别:女，年龄：18，住址：广州暴富路888号，体重：55），这时候如果不重写Object的equals方法，那么返回的一定是false不相等，这个时候就需要我们根据自己的需求重写equals()方法了。

1.  
   package jianlejun.study;
2.  
    
3.  
   public class Student {
4.  
   private String name;// 姓名
5.  
   private String sex;// 性别
6.  
   private String age;// 年龄
7.  
   private float weight;// 体重
8.  
   private String addr;// 地址
9.  
    
10.  
    // 重写hashcode方法
11.  
    @Override
12.  
    public int hashCode() {
13.  
    int result = name.hashCode();
14.  
    result = 17 * result + sex.hashCode();
15.  
    result = 17 * result + age.hashCode();
16.  
    return result;
17.  
    }
18.  
     
19.  
    // 重写equals方法
20.  
    @Override
21.  
    public boolean equals(Object obj) {
22.  
    if(!(obj instanceof Student)) {
23.  
    // instanceof 已经处理了obj = null的情况
24.  
    return false;
25.  
    }
26.  
    Student stuObj = (Student) obj;
27.  
    // 地址相等
28.  
    if (this == stuObj) {
29.  
    return true;
30.  
    }
31.  
    // 如果两个对象姓名、年龄、性别相等，我们认为两个对象相等
32.  
    if (stuObj.name.equals(this.name) && stuObj.sex.equals(this.sex) && stuObj.age.equals(this.age)) {
33.  
    return true;
34.  
    } else {
35.  
    return false;
36.  
    }
37.  
    }
38.  
     
39.  
    public String getName() {
40.  
    return name;
41.  
    }
42.  
     
43.  
    public void setName(String name) {
44.  
    this.name = name;
45.  
    }
46.  
     
47.  
    public String getSex() {
48.  
    return sex;
49.  
    }
50.  
     
51.  
    public void setSex(String sex) {
52.  
    this.sex = sex;
53.  
    }
54.  
     
55.  
    public String getAge() {
56.  
    return age;
57.  
    }
58.  
     
59.  
    public void setAge(String age) {
60.  
    this.age = age;
61.  
    }
62.  
     
63.  
    public float getWeight() {
64.  
    return weight;
65.  
    }
66.  
     
67.  
    public void setWeight(float weight) {
68.  
    this.weight = weight;
69.  
    }
70.  
     
71.  
    public String getAddr() {
72.  
    return addr;
73.  
    }
74.  
     
75.  
    public void setAddr(String addr) {
76.  
    this.addr = addr;
77.  
    }
78.  
     
79.  
    }

现在我们写个例子测试下结果：

1.  
   public static void main(String[] args) {
2.  
   Student s1 =new Student();
3.  
   s1.setAddr("1111");
4.  
   s1.setAge("20");
5.  
   s1.setName("allan");
6.  
   s1.setSex("male");
7.  
   s1.setWeight(60f);
8.  
   Student s2 =new Student();
9.  
   s2.setAddr("222");
10.  
    s2.setAge("20");
11.  
    s2.setName("allan");
12.  
    s2.setSex("male");
13.  
    s2.setWeight(70f);
14.  
    if(s1.equals(s2)) {
15.  
    System.out.println("s1==s2");
16.  
    }else {
17.  
    System.out.println("s1 != s2");
18.  
    }
19.  
    }

在重写了student的equals方法后，这里会输出s1 == s2,实现了我们的需求，如果没有重写equals方法，那么上段代码必定输出s1!=s2。

通过上面的例子，你是不是会想，不是说要同时重写Object的equals方法和hashcode方法吗？那上面的例子怎么才只用到equals方法呢，hashcode方法没有体现出来，不要着急，我们往下看。

四。需要重写hashcode()的场景

以上面例子为基础，即student1和student2在重写equals方法后被认为是相等的。

在两个对象equals的情况下进行把他们分别放入Map和Set中

在上面的代码基础上追加如下代码：

1.  
   Set set = new HashSet();
2.  
   set.add(s1);
3.  
   set.add(s2);
4.  
   System.out.println(set);

如果没有重写Object的hashcode()方法（即去掉上面student类中hashcode方法块），这里会输出

[jianlejun.study.Student@7852e922, jianlejun.study.Student@4e25154f]

说明该Set容器类有2个元素。.........等等，为什么会有2个元素？？？？刚才经过测试，s1不是已经等于s2了吗，那按照Set容器的特性会有一个去重操作，那为什么现在会有2个元素。这就涉及到Set的底层实现问题了，这里简单介绍下就是HashSet的底层是通过HashMap实现的，最终比较set容器内元素是否相等是通过比较对象的hashcode来判断的。现在你可以试试吧刚才注释掉的hashcode方法弄回去，然后重新运行，看是不是很神奇的就只输出一个元素了

1.  
   @Override
2.  
   public int hashCode() {
3.  
   int result = name.hashCode();
4.  
   result = 17 * result + sex.hashCode();
5.  
   result = 17 * result + age.hashCode();
6.  
   return result;
7.  
   }

 或许你会有一个疑问？hashcode里的代码该怎么理解？该如何写？其实有个相对固定的写法，先整理出你判断对象相等的属性，然后取一个尽可能小的正整数(尽可能小时怕最终得到的结果超出了整型int的取数范围)，这里我取了17，（好像在JDK源码中哪里看过用的是17），然后计算17*属性的hashcode+其他属性的hashcode，重复步骤。

重写hashcode方法后输出的结果为：

[jianlejun.study.Student@43c2ce69]

同理，可以测试下放入HashMap中，key为<s1,s1>，<s2,s2>,Map也把两个同样的对象当成了不同的Key（Map的Key是不允许重复的，相同Key会覆盖)那么没有重写的情况下map中也会有2个元素，重写的情况会最后put进的元素会覆盖前面的value

1.  
   Map m = new HashMap();
2.  
   m.put(s1, s1);
3.  
   m.put(s2, s2);
4.  
   System.out.println(m);
5.  
   System.out.println(((Student)m.get(s1)).getAddr());
6.  
    
7.  
   输出结果：
8.  
   {jianlejun.study.Student@43c2ce69=jianlejun.study.Student@43c2ce69}
9.  
   222

 可以看到最终输出的地址信息为222，222是s2成员变量addr的值，很明天，s2已经替换了map中key为s1的value值，最终的结果是map<s1,s2>。即key为s1value为s2.

 五。原理分析

因为我们没有重写父类（Object）的hashcode方法,Object的hashcode方法会根据两个对象的地址生成对相应的hashcode；

s1和s2是分别new出来的，那么他们的地址肯定是不一样的，自然hashcode值也会不一样。

Set区别对象是不是唯一的标准是，两个对象hashcode是不是一样，再判定两个对象是否equals;

Map 是先根据Key值的hashcode分配和获取对象保存数组下标的，然后再根据equals区分唯一值（详见下面的map分析）

六。补充HashMap知识

hashMap组成结构：hashMap是由数组和链表组成；

hashMap的存储：一个对象存储到hashMap中的位置是由其key 的hashcode值决定的;查hashMap查找key: 找key的时候hashMap会先根据key值的hashcode经过取余算法定位其所在数组的位置，再根据key的equals方法匹配相同key值获取对应相应的对象；

案例：

（1）hashmap存储

存值规则：把Key的hashCode 与HashMap的容量 取余得出该Key存储在数组所在位置的下标（源码定位Key存储在数组的哪个位置是以hashCode & (HashMap容量-1)算法得出）这里为方便理解使用此方式；

//为了演示方便定义一个容量大小为3的hashMap（其默认为16）

HashMap map=newHashMap(3);

map.put("a",1); 得到key 为“a” 的hashcode 值为97然后根据 该值和hashMap 容量取余97%3得到存储位到数组下标为1;

map.put("b",2); 得到key 为“b” 的hashcode 值为98,98%3到存储位到数组下标为2;

map.put("c",3); 得到key 为“c” 的hashcode 值为99，99%3到存储位到数组下标为0;

map.put("d",4); 得到key 为“d” 的hashcode 值为100，100%3到存储位到数组下标为1;

map.put("e",5); 得到key 为“e” 的hashcode 值为101，101%3到存储位到数组下标为2;

map.put("f",6); 得到key 为“f” 的hashcode 值为102，102%3到存储位到数组下标为0;

（2）hashmap的查找key

得到key在数组中的位置：根据上图，当我们获取key 为“a”的对象时，那么我们首先获得 key的hashcode97%3得到存储位到数组下标为1;

匹配得到对应key值对象：得到数组下表为1的数据“a”和“c”对象， 然后再根据 key.equals()来匹配获取对应key的数据对象；

hashcode 对于HashMapde:如果没有hashcode 就意味着HashMap存储的时候是没有规律可寻的，那么每当我们map.get()方法的时候，就要把map里面的对象一一拿出来进行equals匹配，这样效率是不是会超级慢；

5、hashcode方法文档说明

在equals方法没被修改的前提下，多次调用同一对象的hashcode方法返回的值必须是相同的整数；

如果两个对象互相equals，那么这两个对象的hashcode值必须相等；

为不同对象生成不同的hashcode可以提升哈希表的性能；

转载地址：https://blog.csdn.net/u012557538/article/details/89861552