HASHMAP源码学习心得

个人HASHMAP源码学习心得共勉 (不足之处,还望指出)

1.HashMap的原理,内部数据结构
    A.JDK1.7是数组 + 链表
    B.JDK1.8底层使用哈希表(数组+链表),当链表过长会将链表转换成红黑树加以实现
2.分析一下HashMap的put方法过程
    A.对KEY求HASH值,然后在计算下标
    B.如果没有碰撞,直接放入桶中
    C.如果碰撞了 ,以链表的方式链接到后面
    D.如果链表长度超过阀值(TREEIFY_THRESHOLD == 8 ),就把链表转换成红黑树
    E.如果节点已经存在就替换
    F.如果桶满了(容量(16) * 加载因子(0.75)),就需要resize(扩容)

hashmap的put的核心代码如一下代码所示

/*  
    hashMap中PUT(K,V)源码核心分析
    hashmap中putVal( [hashmap-> put() --> putVal() ] )方法部分核心代码讲解
    三种情况
    1.KEY值相同,直接替换老的值就可以
    2.KEY值不同,红黑树处理
    3.KEY值不同,链表处理
*/
Node<K,V>[] tab; Node<K,V> p; int n, i;
                        if ((tab = table) == null || (n = tab.length) == 0) //KEY值相同,直接替换老的值就可以
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)//KEY值不同,红黑树处理
            tab[i] = newNode(hash, key, value, null);
        else {//KEY值不同,链表处理
            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);//链表长度超过阀值(TREEIFY_THRESHOLD == 8 ),将链表转换成红黑树
                        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;
            }

3.HashMap中的hash函数是怎么实现的?还有哪些hash的实现方式?
    A.高16bit不变,低16bit和高16bit做一个异或
    B.(n-1) & hash --> 得到下标
    C.还有哪些HASH实现方式 :可以百度再看看
4.HashMap怎么解决冲突,讲一下扩容过程,假如一个值在原数组中,现在移动了新数组,位置肯定改变了,那是什么定位到在这个值新数组中的位置 
    A.将新节点加到链表之后
    B.容量扩充为原来的两倍,然后对每个节点重新计算哈希值
    C.这个值只可能在两个地方,一个是原下标的位置,另一种是在下标为<原下标 + 原容量>的位置

//hashmap核心的rresize()方法详解
final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        //数组初始化 和 扩容  的时候判断
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
                /*
                    判断原来数组有无超过数组的最大值 2^30 
                        超过最大值 直接return出来
                        未超过最大值,直接进行扩容(如 double threshold所示代码段)
                            数组大小的扩容
                            数组容量 * 加载因子扩容 
                     
                */
            if (oldCap >= MAXIMUM_CAPACITY) {
               threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {
            /*  初始化的时候操作
                数组初始化大小是16 = 2^4              
                以及需要扩容的大小 
                    容量(16) 
                        * 
                    加载因子(0.75) 
                    ------------------
                    result   12
            */
            // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        /*
            前提:必须要保证数组位置上的节点不为空
            1.数组位置不为空
            2.数组下标位置不为空
                A.单纯的NODE节点
                B.数组下标位置不为空,但下面为红黑树
                C.数组下标位置不为空,但下面为链表
            
        */
        if (oldTab != null) {//1.数组位置不为空
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {//2.数组下标位置不为空
                    oldTab[j] = null;
                    if (e.next == null) //A.单纯的NODE节点
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)//B.数组下标位置不为空,但下面为红黑树
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else {//C.数组下标位置不为空,但下面为链表 
                        //遍历链表具体如下操作 
                        //主要是 新老数组 链表的对比操作
                        // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {//原下标的位置
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;//<原下标 + 原容量>的位置
                        }
                    }
                }
            }
        }
        return newTab;
    }

5.针对HashMap中的某个Entry链太长,查找时间复杂度可能达到0(n),怎么优化?
    将链表转换成红黑树.JDK1.8已经实现.(部分核心代码如下分析所示)

//链表转换成红黑树核心代源码分析
               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;
                }