Java 8 HashMap（二）—— resize（）初始化和扩容方法和get（）查找方法

废话不多说直接上代码，说明都在代码注释上

一、resize方法

    final Node<K, V>[] resize() {
        //获得当前Map的Node数组，此步骤在于不直接对table进行修改
        Node<K, V>[] oldTab = table;
        //获取当前Map的容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //获取当前Map扩容位置
        int oldThr = threshold;
        //定义新的Map容量和扩容位置
        int newCap, newThr = 0;
        //判断当前Map是否初始化过
        if (oldCap > 0) {
            //已初始化
            //当前容量大于最大容量
            if (oldCap >= MAXIMUM_CAPACITY) {
                //将扩容大小设置为Integer.MAX_VALUE这个值大于最大容量
                //意义在于将当前Map设置为不可扩容
                threshold = Integer.MAX_VALUE;
                //返回旧数组
                return oldTab;
                //如果当前Map的容量的两倍小于最大容量，并且当前Map容量大于默认初始化容量
            } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) {
                //则新Map的容量和扩容位置为当前Map的容量和扩容位置的两倍
                newThr = oldThr << 1;
            }
        } else if (oldThr > 0) {
            //未初始化但Map扩容位置大于0,也就是说你指定了初始化容量，则当前Map的容量的值等于扩容位置的值
            //则新Map的容量设置为当前Map的扩容位置
            newCap = oldThr;
        } else {
            //未初始化，且不是指定容量创建Map
            //使用默认参数
            newCap = DEFAULT_INITIAL_CAPACITY;//16
            newThr = (int) (DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);//12
        }
        if (newThr == 0) {
            //到这一步则说明是从if (oldThr > 0)这一步过来的
            //这一步操作在于修正扩容位置，使它不等于容量大小
            float ft = (float) newCap * loadFactor;
            //当新容量小于最大容量，且新扩容位置小于最大容量则为ft，否则为Integer.MAX_VALUE（不允许再扩容）
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ? (int) ft : Integer.MAX_VALUE);
        }
        //设置扩容位置
        threshold = newThr;
        //用得到的新容量值创建Node数组
        Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
        //设置新的Node数组
        table = newTab;
        //如果旧Node数组不为null且有数据，则进行数据迁移
        if (oldTab != null) {
            //遍历旧数组
            for (int j = 0; j < oldCap; ++j) {
                //e用于获取旧数组的Node指针
                Node<K, V> e;
                if ((e = oldTab[j]) != null) {
                    //将就数组的引用指向null，便于垃圾回收
                    oldTab[j] = null;
                    //如果当前位置上没有链表或红黑树
                    if (e.next == null) {
                        //直接将Node放入新数组
                        newTab[e.hash & (newCap - 1)] = e;
                    } else if (e instanceof TreeNode) {
                        //当前位置上有红黑树,则用红黑数的方法放置
                        ((TreeNode) e).split(this, newTab, j, oldCap);
                    } else {
                        //当前位置上有链表
                        /*下述操作将当前节点上的链表分割为两部分*/
                        //低位链表头，低位链表尾
                        Node<K, V> loHead = null, loTail = null;
                        //高位链表头，高位链表尾
                        Node<K, V> hiHead = null, hiTail = null;
                        Node<K, V> next;
                        do {
                            //遍历链表
                            //获得链表Node的下一个Node
                            next = e.next;
                            //注意此处&运算的oldCap没有-1
                            //那么旧数组的容量值二进制表达必定为：1000 ...，所以此处计算只有两个结果，1或者0
                            //所以Node在新数组的位置要么是原位置，要么是原位置加上旧数组容量值的位置
                            if ((e.hash & oldCap) == 0) {
                                //如果当前Node与旧数组容量计算的值等于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;
    }

二、get方法

    @Override
    public V get(Object key) {
        Node<K, V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    final Node<K, V> getNode(int hash, Object key) {
        //获得当前Node数组，此步骤在于不直接对table进行修改
        Node<K, V>[] tab = table;
        Node<K, V> first, e;
        //获得当前数组容量
        int n = tab.length;
        K k;
        //如果当前数组不为null且长度大于0，
        //并且通过参数Key获得的节点不为null
        if (tab != null && n > 0 &&
                (first = tab[(n - 1) & hash]) != null) {
            //比较当前Node哈希值与传入哈希值
            if (first.hash == hash) {
                //如果相等，获得当前Node的key
                k = first.key;
                //如果当前Node的key与传入Key相等
                if (Objects.equals(key, k)) {
                    //当前Node就是要找的Node，返回当前Node
                    return first;
                }
            }
            //如果当前Node哈希值与传入哈希值不相等，且当前Node上有链表或红黑树
            if ((e = first.next) != null) {
                //判断当前Node是否是红黑树TreeNode
                if (first instanceof TreeNode) {
                    //如果是，则用TreeNode的getTreeNode方法查找Node
                    return ((TreeNode<K, V>) first).getTreeNode(hash, key);
                }
                //如果是链表
                do {
                    //遍历链表，查找Node
                    if (e.hash == hash) {
                        k = e.key;
                        if (Objects.equals(key, k)) {
                            //找到Node返回
                            return e;
                        }
                    }
                } while ((e = e.next) != null);
            }
        }
        //找不到返回null
        return null;
    }