×

equals和hashCode的区别和联系

96
叫我宫城大人
2017.08.23 18:44* 字数 2201

一、前言

前段时间使用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;
}
Java基础知识
Web note ad 1