JAVA重写hashCode通用方法(摘录自《Effective Java》),重写hashcode和equals

JAVA重写hashCode通用方法(摘录自《Effective Java》),重写hashcode和equals

  1. 初始化一个整形变量,为此变量赋予一个非零的常数值,比如int result =
    17;
  2. 选取equals方法中用于比较的所有域,然后针对每个域的属性进行计算:
    (1) 如果是boolean值,则计算f ? 1:0
    (2) 如果是byte\char\short\int,则计算(int)f
    (3) 如果是long值,则计算(int)(f ^ (f >>> 32))
    (4) 如果是float值,则计算Float.floatToIntBits(f)
    (5)
    如果是double值,则计算Double.doubleToLongBits(f),然后返回的结果是long,再用规则(3)去处理long,得到int
    (6)
    如果是对象应用,如果equals方法中采取递归调用的比较方式,那么hashCode中同样采取递归调用hashCode的方式。  否则需要为这个域计算一个范式,比如当这个域的值为null的时候,那么hashCode
    值为0
    (7)
    如果是数组,那么需要为每个元素当做单独的域来处理。如果你使用的是1.5及以上版本的JDK,那么没必要自己去    重新遍历一遍数组,java.util.Arrays.hashCode方法包含了8种基本类型数组和引用数组的hashCode计算,算法同上,
      java.util.Arrays.hashCode(long[])的具体实现:

    public static int hashCode(long a[]) {

         if (a == null)  
             return 0;  
    
         int result = 1;  
         for (long element : a) {  
             int elementHash = (int)(element ^ (element >>> 32));  
             result = 31 * result + elementHash;  
         }  
    
         return result;  
    

    }

example: 

package com.kingdee.cloudhub.stat.domains;

import java.util.Arrays;

public class Person {
 private int age;

 private String name;

 private char sex;

 private String[] hoby;

 public Person(int age, char sex, String name, String[] hoby) {
  this.age = age;
  this.sex = sex;
  this.name = name;
  this.hoby = hoby;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public char getSex() {
  return sex;
 }

 public void setSex(char sex) {
  this.sex = sex;
 }

 public String[] getHoby() {
  return hoby;
 }

 public void setHoby(String[] hoby) {
  this.hoby = hoby;
 }

 public int hashCode() {
  int result = 1;
  result = 31 * result + age;
  result = 31 * result + sex;
  result = 31 * result + name.hashCode();
  for(String s : hoby) {
   result = 31 * result + s.hashCode();
  }
  return result;
 }

 public boolean equals(Object obj) {
  if(null == obj)
   return false;
  if(this == obj)
   return true;
  if (!(obj instanceof Person))
            return false;
  Person p = (Person)obj;
  return this.age == p.age && this.sex == p.sex
    && this.name.equals(p.name) && Arrays.equals(this.hoby, p.hoby);
 }

}

  

http://www.bkjia.com/Javabc/1192095.htmlwww.bkjia.comtruehttp://www.bkjia.com/Javabc/1192095.htmlTechArticleJAVA重写hashCode通用方法(摘录自《Effective
Java》),重写hashcode和equals 1.
初始化一个整形变量,为此变量赋予一个非零的常数值,比如int resu…

一、前言

前段时间使用list.remove(obj)的时候重写了obj的equals方法,因为list的remove是以equals来判断标准的。但是,今天被公司的代码扫描工具提示未重写hashCode方法!!之前准备面试时也多少看过,但是没有细细研究过这个hashCode和equals到底背后是什么个关系,趁此机会,总结一波。

本文章所用到的自定义测试对象类Stu:

public class Stu {
  private String name;
  private int age;

  Stu(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  }
}

二、equals的具体作用

首先要说的是equals是Object的方法,所以只能用于对象间,基本类型之间比较用“==”,反则他们的封装类型可以用equals。

public static void main(String[] args) {
  Stu s1 = new Stu("张三", 18);
  Stu s2 = new Stu("张三", 18);
  System.out.println("stu:" + s1.equals(s2));

  Integer i1 = new Integer(18);
  Integer i2 = new Integer(18);
  System.out.println("Integer:" + i1.equals(i2));

  String str1 = "张三";
  String str2 = "张三";
  System.out.println("String:" + str1.equals(str2));
}

很简单,可以得到下面的结果:

stu:false
Integer:true
String:true

通过idea工具可以看到各自的equals实现代码:

Stu

public boolean equals(Object obj) {
    return (this == obj);
}

Integer

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

String

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String) anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                        return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

Stu因为没有重写equals方法,所以直接使用的父类Object的equals方法,后面Integer和String都各自实现了自己的equals方法,所以Integer(基本类型)的equals实际上都是用的自己的实际值比较,String则是逐个char比较相等于否。

三、hashCode的具体作用

hashcode方法返回该对象的哈希码值。支持该方法是为哈希表提供一些优点,例如,java.util.Hashtable
提供的哈希表。

hashCode 的常规协定是:
在 Java 应用程序执行期间,在同一对象上多次调用 hashCode
方法时,必须一致地返回相同的整数,前提是对象上 equals
比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行,该整数无需保持一致。

以下情况不 是必需的:如果根据 equals(java.lang.Object)
方法,两个对象不相等,那么在两个对象中的任一对象上调用 hashCode
方法必定会生成不同的整数结果。但是,程序员应该知道,为不相等的对象生成不同整数结果可以提高哈希表的性能。

实际上,由 Object 类定义的 hashCode
方法确实会针对不同的对象返回不同的整数。(这一般是通过将该对象的内部地址转换成一个整数来实现的,但是
JavaTM 编程语言不需要这种实现技巧。)

当equals方法被重写时,通常有必要重写 hashCode 方法,以维护 hashCode
方法的常规协定,该协定声明相等对象必须具有相等的哈希码。

上面是引用的官方文档上面的一段话,我们需要他说人话:

  1. 对象equals方法参与运算的自身属性attr不能被修改,并且同一个对象的hashCode值任何时候的返回值都应该相等;
  2. hashCode不等的两个对象equals一定不相等,但是hashCode相等的两个对象equals不一定相等;
  3. 根据规定,重写对象的equals方法必须重写hashCode方法,尽管不写也能通过编译;

这里引用网上一个很容易理解的例子:

hashcode是用来查找的,如果你学过数据结构就应该知道,在查找和排序这一章有
例如内存中有这样的位置
0 1 2 3 4 5 6 7
而我有个类,这个类有个字段叫id,我要把这个类存放在以上8个位置之一,如果不用hashcode而任意存放,那么当查找时就需要到这八个位置里挨个去找,或者用二分法一类的算法。
但如果用hashCode那就会使效率提高很多。
我们这个类中有个字段叫id,那么我们就定义我们的hashCode为id%8,然后把我们的类存放在取得得余数那个位置。比如我们的ID为9,9除8的余数为1,那么我们就把该类存在1这个位置,如果ID是13,求得的余数是5,那么我们就把该类放在5这个位置。这样,以后在查找该类时就可以通过ID除
8求余数直接找到存放的位置了。

但是如果两个类有相同的hashCode怎么办那(我们假设上面的类的id不是唯一的),例如9除以8和17除以8的余数都是1,那么这是不是合法的,回答是:完全合法。那么如何判断呢?在这个时候就需要定义equals了。
也就是说,我们先通过
hashCode来判断两个类是否存放某个桶里,但这个桶里可能有很多类,那么我们就需要再通过
equals 来在这个桶里找到我们要的类。
那么。重写了equals(),为什么还要重写hashCode()呢?
想想,你要在一个桶里找东西,你必须先要找到这个桶啊,你不通过重写hashCode()来找到桶,光重写equals()有什么用啊。

可能太过文本的东西没有什么说服力,那就来点干货:

public static void main(String[] args) {
  Stu s1 = new Stu("张三", 18);
  Stu s2 = new Stu("张三", 18);
  System.out.println("stu:" + s1.equals(s2));

  Set<Stu> set = new HashSet<>();
  set.add(s1);
  System.out.println("s1 hashCode:" + s1.hashCode());
  System.out.println("add s1 size:" + set.size());
  set.add(s2);
  System.out.println("s2 hashCode:" + s2.hashCode());
  System.out.println("add s2 size::" + set.size());
}

输出结果:

stu:false
s1 hashCode:1317241155
add s1 size:1
s2 hashCode:463175162
add s2 size::2

Java中的Set是不允许有重复元素的,所以这里set的size由1变成了2,因为两个Stu都是new出来的,分配的地址不一样,那么Set是通过equals来定义重复的吗?

首先重写Stu的equals方法:

@Override
public boolean equals(Object obj) {
  if (obj == null){
    return false;
  }
  if (obj.getClass() != getClass()){
    return false;
  }
  return ((Stu)obj).getName().equals(getName());
}

输出结果:

stu:true
s1 hashCode:713679046
add s1 size:1
s2 hashCode:1107557627
add s2 size::2

重写equals方法,name相同就让equals返回true了,但是Set的size还是发生了改变,就说明不是有equals方法来定义重复的,现在仅仅重写hashCode方法:

@Override
public int hashCode() {
  return getName().hashCode();
}

输出结果:

stu:false
s1 hashCode:774889
add s1 size:1
s2 hashCode:774889
add s2 size::2

仅重写了hashCode方法,所以equals返回false,然后hashCode由name属性的hashCode方法得到,所以hashCode相等,但是Set的size还是改变了,这说明Set也不是仅仅依据hashCode来定义重复。

那么现在将上述equals和hashCode两者同时重写,输出结果:

stu:true
s1 hashCode:774889
add s1 size:1
s2 hashCode:774889
add s2 size::1

结合上面引用的案例,可以类推,hash类存储结构(HashSet、HashMap等等)添加元素会有重复性校验,校验的方式就是先取hashCode判断是否相等(找到对应的位置,该位置可能存在多个元素),然后再取equals方法比较(极大缩小比较范围,高效判断),最终判定该存储结构中是否有重复元素。

四、总结

  1. hashCode主要用于提升查询效率,来确定在散列结构中对象的存储地址;
  2. 重写equals()必须重写hashCode(),二者参与计算的自身属性字段应该相同;
  3. hash类型的存储结构,添加元素重复性校验的标准就是先取hashCode值,后判断equals();
  4. equals()相等的两个对象,hashcode()一定相等;
  5. 反过来:hashcode()不等,一定能推出equals()也不等;
  6. hashcode()相等,equals()可能相等,也可能不等。

五、花边:通用的hashCode重写方案

初始化一个整形变量,为此变量赋予一个非零的常数值,比如int result = 17;
必发线上娱乐,选取equals方法中用于比较的所有域,然后针对每个域的属性进行计算:

  1. 如果是boolean值,则计算f ? 1:0
  2. 如果是byte\char\short\int,则计算(int)f
  3. 如果是long值,则计算(int)(f ^ (f >>> 32))
  4. 如果是float值,则计算Float.floatToIntBits(f)
  5. 如果是double值,则计算Double.doubleToLongBits(f),然后返回的结果是long,再用规则(3)去处理long,得到int
  6. 如果是对象应用,如果equals方法中采取递归调用的比较方式,那么hashCode中同样采取递归调用hashCode的方式。否则需要为这个域计算一个范式,比如当这个域的值为null的时候,那么hashCode
    值为0
  7. 如果是数组,那么需要为每个元素当做单独的域来处理。如果你使用的是1.5及以上版本的JDK,那么没必要自己去重新遍历一遍数组,java.util.Arrays.hashCode方法包含了8种基本类型数组和引用数组的hashCode计算,算法同上

给个简单的例子:

@Override
public int hashCode() {
  int result = 17;
  result = 31 * result + getName().hashCode();
  return result;
}