覆盖equals时总要覆盖hashCode

Posted 2020-09-05

本文涉及到的概念

1.为什么重载equals方法时，要重载hashCode函数;没有重载hashCode带来的问题

2.一个对象hashCode的生成规则

 

 

 

1.为什么重载equals方法时，要重载hashCode函数

“

一个很常见的错误根源在于没有覆盖hashCode方法。在每个覆盖了equals方法的类中，也必须覆盖hashCode方法。如果不这样做，就会违反Object.hashCode的通用约定，从而导致该类无法结合所有基于散列的集合一起正常运作，这样的集合包括HashMap,HashSet和Hashtable。

”也就是，在重载equals方法时，如果没有重写hashCode方法，给当前对象生成一个唯一的hashCode，那么，该对象无法在基于散列的集合中正常工作。基于散列的集合，要求集合中的每个元素都有唯一的hashCode。

 

约定：

• 在应用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对这同一个对象调用多次，hashCode方法都必须始终如一地返回同一个整数。在同一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。

 

• 如果两个对象根据equals(Object)方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。

 

 

• 如果两个对象根据equals(Object)方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生不同的整数结果。给不相等的对象产生截然不同的整数结果，有可能提高散列表的性能。

 

因为没有覆盖hashCode方法而违反的关键约定是第二条:相等的对象必须具有相等的散列码(hash code)。根据类的equals方法，两个截然不同的实例在逻辑上有可能是相等的，但是，根据Object类的hashCode方法，它们仅仅是两个没有任何共同之处的对象。因此，对象的hashCode方法返回两个看起来是随机的整数，而不是根据第二个约定所要求的那样，返回两个相等的整数。

 

如果不重载hashCode方法：

import java.util.*;

public final class PhoneNumber {
private final short areaCode;
private final short prefix;
private final short lineNumber;

public PhoneNumber(int areaCode, int prefix, int lineNumber) {
rangeCheck(areaCode, 999, "area code");
rangeCheck(prefix, 999, "prefix");
rangeCheck(lineNumber, 9999, "line number");
this.areaCode = (short) areaCode;
this.prefix = (short) prefix;
this.lineNumber = (short) lineNumber;
}

private static void rangeCheck(int arg, int max, String name) {
if (arg < 0 || arg > max)
throw new IllegalArgumentException(name + ": " + arg);
}

@Override
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof PhoneNumber))
return false;
PhoneNumber pn = (PhoneNumber) o;
return pn.lineNumber == lineNumber && pn.prefix == prefix && pn.areaCode == areaCode;
}

// Broken - no hashCode method!

// A decent hashCode method - Page 48
// @Override public int hashCode() {
// int result = 17;
// result = 31 * result + areaCode;
// result = 31 * result + prefix;
// result = 31 * result + lineNumber;
// return result;
// }

// Lazily initialized, cached hashCode - Page 49
// private volatile int hashCode; // (See Item 71)
//
// @Override public int hashCode() {
// int result = hashCode;
// if (result == 0) {
// result = 17;
// result = 31 * result + areaCode;
// result = 31 * result + prefix;
// result = 31 * result + lineNumber;
// hashCode = result;
// }
// return result;
// }

public static void main(String[] args) {
Map<PhoneNumber, String> m = new HashMap<PhoneNumber, String>();
m.put(new PhoneNumber(707, 867, 5309), "Jenny");
System.out.println(m.get(new PhoneNumber(707, 867, 5309)));
}
}

输出结果为null

期望的是，输出结果是Jenny

分析：

m.put(new PhoneNumber(707, 867, 5309), "Jenny");

创建一个PhoneNumber实例，存放到Map中，该PhoneNumber实例被用作key。

然后，再创建一个实例PhoneNumber，要来从Map中获取映射值。但是，获取不到，我们期望获取到，这两个实例，逻辑上是相等的(使用PhoneNumber中实现的equals方法，可以得出它们是相等的)，虽然它们不是指向同一个对象。

这是因为PhoneNumber类重载了equals方法，但是没有重载hashCode方法，导致两个相等的实例(由PhoneNumber类中的equals来定义)具有不相等的散列码，违反了hashCode的第二条约定（如果两个对象根据equals(Object)方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。）

“put方法把电话号码对象存放在一个散列桶(hash bucket)中，get方法却在另一个散列桶中查找这个电话号码。即使这两个实例正好被放到同一个散列桶中,get方法也必定会返回null，因为HashMap有一项优化，可以将与每个项相关联的散列码缓存起来，如果散列码不匹配，也不必检验对象的等同性。”

解决上述问题，只需要为PhoneNumber重载hashCode方法，返回一个hashCode(当equals相等时，两个实例返回的hashCode要相等)。

 

2.一个对象hashCode的生成规则

“

一个好的hashcode方法通常最好是不相等的对象产生不相等的hash值，理想情况下，hashcode方法应该把集合中不相等的实例均匀分布到所有可能的hash值上面。

1. 把某个非0的常数值，比如17，保存在一个名为result的int类型的变量中。
2. 对于对象中的每个关键域f，做如下操作：
   1. 为该域计算int类型的哈希值c：
      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)，然后重复第三个步骤。
      6. 如果该域是一个对象引用，并且该类的equals方法通过递归调用equals方法来比较这个域，同样为这个域递归的调用hashCode，如果这个域为null，则返回0。
      7. 如果该域是数组，则要把每一个元素当作单独的域来处理，递归的运用上述规则，如果数组域中的每个元素都很重要，那么可以使用Arrays.hashCode方法。每个元素计算出来的hashCode，使用2.2中的公式，将hashCode组合起来。

　　　２.按照下面的公式，把步骤2.1中计算得到的散列码c合并到result中:

        result = 31 * result + c

３.返回result

4.写完了hashCode方法之后，问问自己"相等的实例是否都具有相等的散列码"。要编写单元测试来验证你的推断。如果相等的实例有着不相等的散列码，则要找出原因，并修正错误。

”

 

一个计算例子:

根据已经实现的equals方法，可以知道，该对象的关键域是lineNumber,prefix,areaCode。

然后，使用这三个关键域来生成hashCode。

 

private final short areaCode;
private final short prefix;
private final short lineNumber;

@Override
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof PhoneNumber))
return false;
PhoneNumber pn = (PhoneNumber) o;
return pn.lineNumber == lineNumber && pn.prefix == prefix && pn.areaCode == areaCode;
}

// A decent hashCode method - Page 48
　@Override public int hashCode() {
　int result = 17;
　result = 31 * result + (int)areaCode;
　result = 31 * result + (int)prefix;
　result = 31 * result + (int)lineNumber;
return result;
}