HashMap扩容机制源码分析（put）方法JDK1.8

jdk1.8中，HashMap采用位桶+链表+红黑树实现，当链表长度超过阈值【8】且数组容量超过64时，将链表转换为红黑树，这样大大减少了查找时间。

首先HashMap在使用put方法存入数据类型时是一个键值对，一个key和所对应的value值

	HashMap<String, String> hashMap = new HashMap<String, String>();
		hashMap.put("hello", "world");

然后进入到put方法的源码

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

里面是只有两个方法，进入到hash这个方法里面

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

        哈希方法根据一个扰动，得到了一个哈希值，找到对应的存放位置，当存入的key是null的时候他的哈希值只能是0

        如果不为null的时候，根据hash扰动函数算出一个哈希值。目的是为了防止过多的哈希冲突

        然后返回看主要扩容的和这个putval往进放元素的方法

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //tab表示当前HasMap的数组
        //p表示当前数组的元素
        //n表示数组数组的长度
        //i路由寻址的结果
        Node<K,V>[] tab; Node<K,V> p; int n, i;

        //判断是否是否进行了初始化
        //如果为初始化，创建一个16长度的泛型数组
        //将长度赋值给n
        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 {
         // 如果有元素。先判断它们的key是否相同
         // 如果key和哈希值相同，将原来的值给到新定义的e
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;

            //判断是不是一个treeNode节点
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {

            
                
                for (int binCount = 0; ; ++binCount) {

                     //如果p的下一个节点的位置是null
                    if ((e = p.next) == null) {
                     //查找哪一个节点的下一个节点为空，直接挂到下一个为空的地方
                        p.next = newNode(hash, key, value, null);

                    //判断挂的地方的长度大于8的时候，走treeifybin变成红黑树的结构
                        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;
                }
            }

            //如果key相同 判断e是不是null，如果不是null
            // 将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;
    }

总结：

          新增过程。

初始化长度为16的一个数组。数组的形式为Node<K,V>[ ] tab;形式为数组+链表+红黑树

1.计算一个哈希地址，如果当前存放的位置为空，给当前的位置直接new一个节点直接存进去

2.如果不为空，发生哈希冲突，判断key是否相同，如果key相同，则覆盖重写。

3.如果值不为null ，发生哈希冲突，结果不同的情况下，在判断是否为树，如果不为树，则判断是否为链表

如果是树形的，用树的方式创建新节点，加载到树上

如果是链表形式，找到下一个元素为null的时候，放新元素。

如果当前链表大于8，数组长度小于64，扩容数组*2

如果数组长度大于64，将当前列表转化成一个红黑树的形式