hashCode方法

Why HashCode?

hashCode()是Java中Object类的一个方法

public native int hashCode();

根据这个方法声明，该方法返回一个int类型哈希值，并且作为native本地方法，在Object类中没有具体实现。

hashCode方法作用

对于集合而言，最重要的就是基于散列的快速查找，快速增删的能力，而hashCode方法方便了hashSet, hashMap, hashTable等等的基于哈希查找的集合正常运行。
一般快速查找对应的下标，要么是像数组一样能够直接快速按照下标一个个取出，否则就得调用equals()方法一个个遍历后比较，但是hashCode牛🐂就牛🐂在它将与此对象相关的字段，映射成一个唯一的数值 （只要你与别人有一点点不一样，那么你俩的hashCode就完全不一样）

实际上在HashMap的具体实现中会用一个table保存已经存进去的对象的hashcode值。
如果table中没有该hashcode值，它就可以直接存进去，不用再进行任何比较了；
如果table存在该hashcode值， 就调用它的equals方法与新元素进行比较，相同的话就不存了；不相同就散列其它的地址。
所以这里存在一个冲突解决的问题，这样一来实际调用equals方法的次数就大大降低了

hashCode方法误区

误区1:
hashCode就是对象存储地址？

有些朋友误以为默认情况下，hashCode返回的就是对象的存储地址，事实上这种看法是不全面的。
确实有些JVM在实现时是直接返回对象的存储地址，但是大多时候并不是这样，只能说可能存储地址有一定关联。下面是HotSpot JVM中生成hash散列值的实现

static inline intptr_t get_next_hash(Thread * Self, oop obj) {
  intptr_t value = 0 ;
  if (hashCode == 0) {
     // This form uses an unguarded global Park-Miller RNG,
     // so it's possible for two threads to race and generate the same RNG.
     // On MP system we'll have lots of RW access to a global, so the
     // mechanism induces lots of coherency traffic.
     value = os::random() ;
  }else
  if (hashCode == 1) {
     // This variation has the property of being stable (idempotent)
     // between STW operations.  This can be useful in some of the 1-0
     // synchronization schemes.
     intptr_t addrBits =intptr_t(obj) >> 3 ;
     value = addrBits ^ (addrBits >> 5) ^ GVars.stwRandom ;
  }else
  if (hashCode == 2) {
     value = 1 ;           // for sensitivity testing
  }else
  if (hashCode == 3) {
     value = ++GVars.hcSequence ;
  }else
  if (hashCode == 4) {
     value =intptr_t(obj) ;
  }else {
     // Marsaglia's xor-shift scheme with thread-specific state
     // This is probably the best overall implementation -- we'll
     // likely make this the default in future releases.
     unsigned t = Self->_hashStateX ;
     t ^= (t << 11) ;
     Self->_hashStateX = Self->_hashStateY ;
     Self->_hashStateY = Self->_hashStateZ ;
     Self->_hashStateZ = Self->_hashStateW ;
     unsigned v = Self->_hashStateW ;
     v = (v ^ (v >> 19)) ^ (t ^ (t >> 8)) ;
     Self->_hashStateW = v ;
     value = v ;
  }
 
  value &= markOopDesc::hash_mask;
  if (value == 0) value = 0xBAD ;
  assert (value != markOopDesc::no_hash,"invariant") ;
  TEVENT (hashCode: GENERATE) ;
  return value;
}

误区2:
hashCode值能直接用于判断两个对象是否相同

有人会说，可以直接根据hashcode值判断两个对象是否相等吗？
肯定是不可以的，因为不同的对象可能会生成相同的hashcode值。虽然不能根据hashcode值判断两个对象是否相等，但是可以直接根据hashcode值判断两个对象不等，如果两个对象的hashcode值不等，则必定是两个不同的对象。
如果要判断两个对象是否真正相等，必须通过equals方法。

总结：
如果有以下两个对象 a, b

• 如果a.equals(b)返回true,则a.hashCode() == b.hashCode()也一定为true
• 如果a.equals(b)返回false,则a.hashCode() == b.hashCode()不一定为false，也可以是true
• 如果a.hashCode() == b.hashCode()，那么a.equals(b)结果也不确定
• 如果a.hashCode() != b.hashCode()，那么a.equals(b)结果一定是false

重写hashCode()

在有些情况下，程序设计者在设计一个类的时候为需要重写equals方法，比如String类。
但是千万要注意，在使用到集合类时，重写equals方法的同时，必须重写hashCode方法。

为什么这么说呢？看这个例子：

package com.java.test1;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
class People{
    private String name;
    private int age;
 
    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  
     
    public void setAge(int age){
        this.age = age;
    }
         
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) &&this.age== ((People)obj).age;
    }
}
public class Main {
    public static void main(String[] args) {
        People p1 =new People("Jack",12);
        System.out.println(p1.hashCode());
             
        HashMap<People, Integer> hashMap =new HashMap<People, Integer>();
        hashMap.put(p1,1);
         
        System.out.println(hashMap.get(new People("Jack",12)));
    }
}

上面的例子：只重写了equals方法，也就说如果两个People对象，如果它的姓名和年龄相等，则认为是同一个人。

1175962212
null

Process finished with exit code 0

原本我们期待最后一行打印的是：1，但实际上输出结果为“null”。原因就在于重写equals方法的同时忘记重写hashCode方法。

虽然通过重写equals方法使得逻辑上姓名和年龄相同的两个对象被判定为相等的对象（跟String类类似），但是要知道默认情况下，hashCode方法是将对象的存储地址进行映射。那么上述代码的输出结果为“null”就不足为奇了。
原因很简单，p1指向的对象和System.out.println(hashMap.get(new People(“Jack”, 12))); 这句中的new People(“Jack”, 12)生成的是两个对象，它们的存储地址肯定不同。

因此，如果想要上述代码输出：1，则只需要重写People类中的hashCode方法，让equals方法和hashCode方法始终在逻辑上保持一致性。
将默认的hashCode方法改写为如下

	@Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()*37 +age;
    }

⚠️上面这段代码仍然有风险：如果name是一个容易改变的字段，最好不要依赖它生成hashCode，否则会因为name的修改导致存储进入hashMap中的数据丢失。

在《Java编程思想》一书中的P495页也有同第一条类似的一段话：
“设计hashCode()时最重要的因素就是：无论何时，对同一个对象调用hashCode()都应该产生同样的值。如果在将一个对象用put()添加进HashMap时产生一个hashCdoe值，而用get()取出时却产生了另一个hashCode值，那么就无法获取该对象了。所以如果你的hashCode方法依赖于对象中易变的数据，用户就要当心了，因为此数据发生变化时，hashCode()方法就会生成一个不同的散列码”。

具体是什么意思呢，下面还是沿用上面的People类举个例子：

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
 
public class Main {
    public static void main(String[] args) {
        People p1 =new People("Jack",12);
        System.out.println(p1.hashCode());
         
        HashMap<People, Integer> hashMap =new HashMap<People, Integer>();
        hashMap.put(p1,1);
         
        p1.setAge(13);
         
        System.out.println(hashMap.get(p1));
    }
}
class People{
    private String name;
    private int age;
     
    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  
     
    public void setAge(int age){
        this.age = age;
    }
     
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()*37+age;
    }
     
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) &&this.age == ((People)obj).age;
    }
}

上面的代码最终输出是：

null

Process finished with exit code 0

由于People类中hashCode的计算依赖于 name 和 age，但是 age在程序中由于setAge()发生了改变,从而同一个对象p1产生了不一样的hashCode,也就无法找到对应在HashMap中存储的原数据了。