hashcode方法 简析

package com.ycgwl;

import java.util.HashMap;

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) {
        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===>"+p1.hashCode());

        HashMap<People, Integer> hashMap = new HashMap<People, Integer>();
        hashMap.put(p1, 1);

        System.out.println("new 对象===>"+new People("Jack", 12).hashCode());

        System.out.println("对比："+hashMap.get(new People("Jack", 12)));

        System.out.println("aa".hashCode());

//    	String aa = "123";
//    	String bb = "123";
//    	String cc = new String("123");
//    	System.out.println(aa.hashCode()+"##"+bb.hashCode()+"***"+cc.hashCode());
//    	System.out.println(aa == bb);
//    	System.out.println(aa == cc);

    }
}

控制台
p1===>139607202
new 对象===>1820973978
对比：null
3104

　　

hashCode的实现原理

 public int hashCode() {
     int h= hash;
     if (h== 0 && value.length > 0) {
        char val[] = value;
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
     return h;
 }

在String类中有个私有实例字段hash表示该串的哈希值，在第一次调用hashCode方法时，字符串的哈希值被计算并且赋值给hash字段，之后再调用hashCode方法便可以直接取hash字段返回。

String类中的hashCode计算方法还是比较简单的，就是以31为权，每一位为字符的ASCII值进行运算，用自然溢出来等效取模。

哈希计算公式可以计为s [0] * 31 ^（n-1）+ s [1] * 31 ^（n-2）+ ... + s [n-1]

关于为什么取31为权？
原因一：主要是因为31是一个奇质数，所以31 * I = 32 * II =（I << 5）-i，这种位移与减法结合的计算相比一般的运算快很多。
原因二：值31被选择，因为它是一个奇数的素数如果它是偶数，并且倍增溢出，则信息将会丢失，因为乘以2移位相当于使用素数的好处不太清楚，但是是传统的.31的一个很好的特性是乘法可以被一个移位和一个减法取代以获得更好的性能：31 * i ==（i << 5） -  i。现代虚拟机自动进行这种优化。

在HashMap中，为什么不能使用基本数据类型作为key？

其实和HashMap底层的存储原理有关，HashMap存储数据的特点是：无序、无索引、不能存储重复元素。

存储元素采用的是hash表存储数据，每存储一个对象的时候，都会调用其hashCode()方法，算出其hash值，如果相同，则认为是相同的数据，直接不存储，如果hash值不同，则再调用其equals方法进行比较，如果返回true，则认为是相同的对象，不存储，如果返回false，则认为是不同的对象，可以存储到HashMap集合中。

之所以key不能为基本数据类型，则是因为基本数据类型不能调用其hashcode()方法和equals()方法，进行比较，所以HashMap集合的key只能为引用数据类型，不能为基本数据类型，可以使用基本数据类型的包装类，例如Integer Double等。

当然，在HashMap存储自定义对象的时候，需要自己再自定义的对象中重写其hashCode()方法和equals方法，才能保证其存储不重复的元素，否则将存储多个重复的对象，因为每new一次，其就创建一个对象，内存地址是不同的。

1.put()

public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //判断当前确定的索引位置是否存在相同hashcode和相同key的元素，如果存在相同的hashcode和相同的key的元素，那么新值覆盖原来的旧值，并返回旧值。
            //如果存在相同的hashcode，那么他们确定的索引位置就相同，这时判断他们的key是否相同，如果不相同，这时就是产生了hash冲突。
            //Hash冲突后，那么HashMap的单个bucket里存储的不是一个 Entry，而是一个 Entry 链。
            //系统只能必须按顺序遍历每个 Entry，直到找到想搜索的 Entry 为止——如果恰好要搜索的 Entry 位于该 Entry 链的最末端（该 Entry 是最早放入该 bucket 中），
            //那系统必须循环到最后才能找到该元素。
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                return oldValue;
            }
        }
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

　　hash值冲突是发生在put()时，从源码可以看出，hash值是通过hash(key.hashCode())来获取的，当put的元素越来越多时，难免或出现不同的key产生相同的hash值问题，也即是hash冲突，当拿到一个hash值，通过indexFor(hash, table.length)获取数组下标，先查询是否存在该hash值，若不存在，则直接以Entry<V,V>的方式存放在数组中，若存在，则再对比key是否相同,若hash值和key都相同，则替换value，若hash值相同，key不相同，则形成一个单链表，将hash值相同，key不同的元素以Entry<V,V>的方式存放在链表中，这样就解决了hash冲突，这种方法叫做分离链表法，与之类似的方法还有一种叫做 开放定址法，开放定址法师采用线性探测（从相同hash值开始，继续寻找下一个可用的槽位）hashMap是数组，长度虽然可以扩大，但用线性探测法去查询槽位查不到时怎么办？因此hashMap采用了分离链表法。

2.get()

public V get(Object key) {
       if (key == null)
           return getForNullKey();
       int hash = hash(key.hashCode());
       for (Entry<K,V> e = table[indexFor(hash, table.length)];
           e != null;
           e = e.next) {
           Object k;
           if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

　　

有了上面存储时的hash算法作为基础，理解起来这段代码就很容易了。从上面的源代码中可以看出：从HashMap中get元素时，首先计算key的hashCode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。

　　当hashMap没出现hash冲突时，没有形成单向链表，get方法能够直接定位到元素，但是，出现冲突后，形成了单向链表，bucket里存放的不再是一个entry对象，而是一个entry对象链，系统只能顺序的遍历每个entry直到找到想要搜索的entry为止，这时，问题就来了，如果恰好要搜索的entry位于该entry链的最末端，那循环必须要进行到最后一步才能找到元素，此时涉及到一个负载因子的概念，hashMap默认的负载因子为0.75，这是考虑到存储空间和查询时间上成本的一个折中值，增大负载因子，可以减少hash表（就是那个entry数组）所占用的内空间，但会增加查询数据的时间开销，而查询是最频繁的操作（put()和get()都用到查询）；减小负载因子，会提高查询时间，但会增加hash表所占的内存空间。

　　结合负载因子的定义公式可知，threshold就是在此loadFactor和capacity对应下允许的最大元素数目，超过这个数目就重新resize，以降低实际的负载因子。默认的的负载因子0.75是对空间和时间效率的一个平衡选择。当容量超出此最大容量时， resize后的HashMap容量是容量的两倍：