Java继承中重写equals和hashCode的注意事项

equals方法: 继承中该方法存在以下的问题: 如果子类能够拥有相等的概念, 则覆盖该方法时应该采用getClass方法; 如果由超类决定相等的概念, 那么就可以使用instanceof进行检测, 这样可以在不同的子类之间进行相等的比较.

具体的重写流程:

• 显式参数使用Object, 命名为otherObject, 稍后可能会进行转换
• 检测是否是同一对象
  • 第一步判断null
  • 第二步, 判断是否是同一类, 判断类时, 如果时前一种情况, 可以使用isinstance关键字进行判断; 如果是第二种情况, 应该用.class属性和getClass()判断.
  • 如果前面的都相同, 对各个实例的对象域使用equals进行判断, 基本类型域用==进行判断. 数组类型可以使用Arrays.equals方法进行判断.

hashCode方法用于对该类实例进行hash时调用, 如果重写了equals就必须重写该方法, 保证equals相等的两个对象具有相同的hashcode. 编写hashCode方法时, 对于实例域的哈希可以调用它自己的hashCode, 更好的方法是使用Object.hashCode方法避免null引起的问题.

还有更好的办法, 可以调用Object.hash提供所有实例域作为参数, 该方法会调用各个实例域的Object.hashCode并将它们组合起来.

toString方法, 在调用print时会调用该对象的toString方法. 该方法的注意点是, 对于数组对象, 直接使用会输出奇奇怪怪的东西, 正确的方法是对Array对象使用Arrays.toString方法.

使用equals做比较时, 可能需要考虑对比的两个对象有null的情况, 这时应该使用Object.equals方法, 当两者均为null时, 返回true.

总结:

• equals 相等，hashCode 一定要相等。
• 重写了 hashCode 也要重写 equals。
• hashCode 需要保持一致性，状态改变返回的哈希值仍然要一致。
• equals 的对称、反射、传递等特性。

什么情况要重写hashcode?

默认的Object中equals是基于==实现的, 比较的是二者的id, hashCode通常是返回的对象的id(JVM中的地址).
当重写了equals基于内容相等时, hashcode也需要基于相同的内容进行hash. 例如Student类的equals方法是比较两个对象的学号是否相等, 则hashCode方法也需要重写比如对字符串按照位数加, 或者直接用学号作为其hash(不是一个好的hash 会聚集).

如果hashcode和equals不一致会发生什么?

例如在HashMap中, 是根据key的hash进行rehash, 然后放置, 如果key相同的两次put, hash是不相同的则没法发现该key是已经存在的, 导致HashMap中有两个相同的key.

Java中常用类型的equals和hashCode重写

1. Integer

   Integer是int的封装类, 它的equals重写为

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

   而这几种整型的hashcode都重写为了自己的基本类型值转int的结果. 例如Integer

   public static int hashCode(int value) {
           return value;
       }
   

2. Short
   Short是short数据类型的封装类, 它的equals和Integer很像, 这里再列举一次以供对比, 之后就不再一一列举

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

   同时它的hashCode的处理和Integer是几乎一模一样的,

   public static int hashCode(short value) {
           return (int)value;
       }
   

3. Byte的处理和上述两个几乎是一样的, 这里就不再一一列举了

4. Long
   Long作为long的封装类, 比较有意思的是它的hashCode的函数, byte, short都可以向上转型到int, 但是long的长度是8个byte, 不能直接转为int, 它的hashCode按照以下方式重写

       public static int hashCode(long value) {
           return (int)(value ^ (value >>> 32));
       }
   

5. Float
   Float是4个byte长度的浮点数, 它的内存空间的解释和int不相同, 但是长度和int是相同的, 那么它的equals和hashCode会如何重写呢?
   首先, 它的equals方法中将Float的原始数据类型的值转换成了int类型的bits, 然后按照int的比较方式去比较两个float是否相等. 因为equals 进行了重写, 所以hashCode同样需要根据equals重写

   public boolean equals(Object obj) {
       return (obj instanceof Float)
              && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
   }
    public static int floatToIntBits(float value) {
    int result = floatToRawIntBits(value);
    // Check for NaN based on values of bit fields, maximum
    // exponent and nonzero significand.
    if ( ((result & FloatConsts.EXP_BIT_MASK) ==
          FloatConsts.EXP_BIT_MASK) &&
         (result & FloatConsts.SIGNIF_BIT_MASK) != 0)
        result = 0x7fc00000;
    return result;
       }
   

   其中floatToIntBits和intBitsToFloat方法是可以相互转换的, 所依赖的floatToRawIntBits是一个native方法. 内部基本遵循IEEE 754 floating-point “single format” bit layout的规范

6. Double
   Double的equals比较的是两个Double转换成的long是否相等, hashCode处理类似Long和Float, 先转换成Long再按照long的方式转成int, 直接看hashCode方法

   public static int hashCode(double value) {
       long bits = doubleToLongBits(value);
       return (int)(bits ^ (bits >>> 32));
   }
   

7. String
   String类的equals也进行了重写, 是基于内容的比较, 具体比较简单, 先判断是否是同一个对象, 接着判断是否是String实例, 如果是的话,比较底层的两个char[]数组的每个元素是否相等. String类需要重点关注一下它的hashCode方法, 虽然也是基于内容的, 但是如果每次按照内容生成一遍hash的开销是比较大的, 而String声明成immutable之后, 由于是不可变的, 所以hash只需要计算一次, 进行缓存之后可以直接比较.

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) { // 空String的hash为0
            char val[] = value;
            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i]; // 以31为基计算循环溢出后的结果
            }
            hash = h; // 缓存到成员变量
        }
        return h;
    }

最后来看下equals和hashCode的典型用途

以下是HashMap的removeNode当中的一个判断是否HashMap中存在带查找的k的语句

if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }

可以看到, 首先比较了k和当前Node e的hash是否相等, 如果相等的话, 进一步比较两者是否==, 如果不是同一个对象, 接着比较equals. 注意, HashMap是允许一个key为null, 键可以为null的, 因此这里需要先判断一下key 是否为null, 这是HashMap中比较待查找键和map中键的通用模式

补充着看一道面试题:

public static void main(String... args) {
	HashMap<Short, Object> map = new HashMap<>();
	for (short i = 1; i < 100; i++) {
		map.put(i, new Object());
		map.remove(i-1);
	}
	System.out.println(map.size());
}

问输出是多少? 结果是100.

原因可以用到上面学过的内容: 问题关键, i-1这个运算会导致向上转型成int, 然后进行自动装箱, 构成一个Integer类型的i-1的对象, 在key != null && key.equals(k)的判断中, Short的equals会判断是否是instanceof, 所以equals返回的false, 没有删掉.