数据结构--jdk1.8 HashMap

HashMap是我们java程序员用到频率最高的一个键值对数据结构，经历过几代版本在jdk1.8时代，HashMap已经和我们认知的HashMap有些差别了。
因此，在java开发的面试中，HashMap被问及的频率也是非常的高，能清晰的认识HashMap的数据结构才能更好的使用HashMap。

1. HashMap概述
HashMap在数据结构被称为散列表。我们通过计算key的hashcode将键值对放入Map中（null的hashCode为0，所以null是可以作为HashMap的key值）。当遇到hash冲突的时候，HashMap将冲突值放入链表或者红黑树。

上图简单描述了HashMap的数据结构，他由一个Node数组table+联表+红黑树组成。
我们将table数组的长度设为L，将要存入的键值为key：value。它的设计大致由以下原则组成
1.table数组的大小必定为2的倍数
2.当Node链表的大小大于等于8时，Node链表转换为Node红黑树
3.当key为null时，hashCode为0
4.当已有的数据size大于HashMap负载threshold时，将执行HashMap扩容操作，扩容后的table长度L为原来的两倍。
5.当某个链表满足转化为红黑树的条件时，table的长度小于MIN_TREEIFY_CAPACITY（64）时，也会执行扩容操作。这个时候数组的长度可能为16，32等，这个时候的扩容操作代价比较小，如果需要在这个时候就转化为红黑树，在下一次扩容的时候必定会将红黑树，拆分成两个链表。
2. HashMap初始化

在执行HashMap的构造函数后，HashMap中的table并未初始化，当且仅当检测都table == null时才执行resize（）函数对table进行初始化。

    /**
     * 在初始化时，threshold值会被赋予大于等于initialCapacity的最小的2幂指数，在调用resize方法初始化table时，threshold会被作为table数组的大小初始化table，并且threshold会被赋予新值
     *
     * @param  initialCapacity 初始容量大小，
     * @param  loadFactor      负载因子
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive
     */
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);//返回大于等于initialCapacity的最小的2幂指数
    }

/**
     * 初始化table数组的大小或对table的size的进行翻倍，如果table为null进行初始化操作，初始化时，如果在构造HashMap指定initialCapacity，threshold将会被作为table的长度进行table初始化，并且threshold将赋予新值threshold * loadFactor
     *
     * @return the table
     */
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        // 对table数组翻倍
        if (oldCap > 0) {
            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
        }
        // initial capacity被指定，用threshold作为初始化table大小
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // 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;
        // 将旧的table中的值放入新的table中
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;// 释放旧值
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        // 红黑树值复制
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        // 如果是链表，将原列表分为两列表，一列对应数组的index不变，一列对应的数组为old table size + index
                        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;
    }

1. 扩容操作
   当hashMap的元素个数大于threshold时，将话触发table扩容操作，这是个比较耗时的操作，建议在初始化HashMap时指定容器可能会用到的容量。
   扩容时，table的大小将会变为原来的两倍。我们将原先的数组设为oldTab长度设为oldCap，新的数组设为newTab长度设为newCap有如下关系：
   oldTab的元素t1-tn所对应的oldTab中的桶为x，那么在newTab中的桶位置必定为x或x+oldCap。那么对于t1-tn等元素，我们对他的hash值进行位运算(hash & oldCap)计算得到不为0则可以将该元素放入newTab中对应的x+oldCap位置上，否则放入位置x。如下图
   (hash & oldCap) == 0运算，转换为更易读的运算就是 （hash / old）%2 == 0

/**
     * table初始化也调用该函数。
     *
     * @return the table
     */
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        // 对table数组翻倍
        if (oldCap > 0) {
            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
        }
        // initial capacity被指定，用threshold作为初始化table大小
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // 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;
        // 将旧的table中的值放入新的table中
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;// 释放旧值
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        // 红黑树值复制
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        // 如果是链表，将原列表分为两列表，一列对应数组的index不变，一列对应的数组为old table size + index
                        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;
    }

红黑树的复制就不贴代码了，大致和链表的思想是一样的，将树分为两截，根据hash值判断，最终得到的树元素个数如果小于等于6就转变为链表。

在面试时经常会被问到关于HashMap的问题，作者在此做个总结，如有偏颇请指，
1.HashMap的容量为什么要被设计成2的幂次？
1）方便对key的hash值进行求余运算，比如map的容量为16则求余只需要对key的hash值余1111进行一次与运算即可得出余
2）在扩容时可以很快速的通过与运算对一个node中元素分到两个table中，否则需要对整个map中的所有元素重新计算它所在的node。
2.HashMap是如何扩容的？
HashMap扩容先将oldTab的容量oldCap翻倍得到newCap，然后遍历oldTab中的node将pos位置的node中的元素的hash值与新的newCap的二进制数进行与运算得到的值如果为0则放到newTab中的pos位置,否则放入oldCap+pos的位置。另外，对于是红黑树的node来说会存在从红黑树转化为链表的问题，即当新得到的node的元素个数小于等于6时转为链表