jdk1.8 HashMap.put(k,v)方法源码阅读

基于jdk1.8的关于hashMap put（K,V)方法阅读

源码：
（1）、跟进第一层方法

 public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

<1>.该方法将入参作为参数调用了putVal(),方法，同时将key做了hash(key)计算，并作为参数继续执行后续方法,跟进hash(key)
说明：h>>>16意思是取出hashCode的高16位比如：

0000 0100 1011 0011  1101 1111 1110 0001
 
>>> 16 
 
0000 0000 0000 0000  0000 0100 1011 0011

<2>然后进行与hashCode进行异或运算，目的是获得更为随机的hashCode值，减小相同hash值的出现的概率

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

（2）、继续深入，该方法为处理put的和新方法，其中引用了其他的重要方法暂不延伸

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

主要方法的理解

<1>、第一个if分支，如果 Node<K,V>[] table 数组为null 或者table.length==0,那么调用resize()方法重新获取table，就是初始化一个新的HashTable对象

if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

<2>、第二if分支，主要是判断数组指定位置上是否有对象存在，该位置不存在对象则调用newNode()方法，将返回的Node对象存放在该位置。

if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);

<3>、第三分支，数组存在值并且计算出数据的指定位置存在对象，接下来处理该种情况
1>、判断当前位置对象的hash是否与新put进来的对象具有相同hash值；当前位置对象hash相同 && （当前对象key值 == put入的key值相同 || key != null && key.equals(k)），个人理解这部分是为了判断基本类型和引用类型采用（ || ）。 当为true时，表示传入了重复对象，将将已存在的p赋值给新Node e。

if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;

2>、判断当前位置的p对象是否为TreeNode类型（由于该节点长度超过链表转换红黑树结构的长度8，），如果时树节点就调用putTreeVal()方法，并将返回的对象赋值给新Node e。

 else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

3>、新put到该位置的对象不存在，并且该node节点不是树结构，在该位置为已存在对象的链表结构，循环该链表找位置插入。
1>>、节点的next == null，则根据传输k/v创建新Node，并根据链表长度判断是否需要转红黑树结构（转换阈值8）如果满足转换阈值则调用treeifyBin方法存入，结束循环

如果循环中判断出已经存在该对象则结束循环。
否则将继续循环下一个对象，直至节点为null追加，或者存在该对象结束方法

else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }

4>、如果Node e不为空说明该位置对象与put进来的对象key一致,将put进来的value赋值给此时对象的value即可完成put.可以理解为更新了原来的对象的value

 if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }

5>、如果当前容量大于阈值则进行扩容

 if (++size > threshold)
            resize();

6>、Callbacks to allow LinkedHashMap post-actions，是为了继承HashMap的LinkedHashMap类服务的。

afterNodeInsertion(evict);

引申

0000 0100 1011 0011  1101 1111 1110 0001
 
>>> 16 
 
0000 0000 0000 0000  0000 0100 1011 0011

个人观点：补充一些，hashcode为int类型，4个字节32位，为了确保散列性，肯定是32位都能进行散列算法计算是最好的。 首先要明白，为什么用亦或计算，二进制位计算，a 只可能为0,1，b只可能为0,1。a中0出现几率为1/2,1也是1/2，b同理。 位运算符有三种，|，&，……，或，与，亦或。 a,b进行位运算，有4种可能 00，01,10,11 a或b计算 结果为1的几率为3/4,0的几率为1/4 a与b计算 结果为0的几率为3/4,1的几率为1/4, a亦或b计算 结果为1的几率为1/2,0的几率为1/2 所以，进行亦或计算，得到的结果肯定更为平均，不会偏向0或者偏向1，更为散列。 右移16位进行亦或计算，我将其拆分为两部分，前16位的亦或运算，和后16位的亦或运算， 后16位的亦或运算，即原hashcode后16位与原hashcode前16位进行亦或计算，得出的结果，前16位和后16位都有参与其中，保证了 32位全部进行计算。 前16位的亦或运算，即原hasecode前16位与0000 0000 0000 0000进行亦或计算，结果只与前16位hashcode有关，同时亦或计算，保证 结果为0的几率为1/2,1的几率为1/2，也是平均的。 所以为什么是右移16位，个人觉得博主说的原因是一部分， 也有一个原因是右移16位进行亦或计算的结果中， （1）结果的后16位保证了hashcode32位全部参与计算，也保证了0,1平均，散列性 （2）结果的前16位保证hashcode前16位了0，1平均散列性，附带hashcode前16位参与计算。 (3) 16与16位数相同，利于计算，不需要补齐，移去位数数据 更多情况，hashmap只会用到前16位（临时数据一般不会这么大），所以（1）占主因