数据结构--jdk1.8 HashMap

来源：互联网发布：吉林动画学院网络教育编辑：程序博客网时间：2024/06/14 17:20

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;    }

扩容操作
当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就转变为链表。

0 0