JDK源码学习之集合框架HashMap

前言：

先上Java集合框架框图，已对其整体把握

概述

本文将解析HashMap的工作原理，put()和get()方法的过程是如何实现的，equals()和hashCode()的都有什么作用，HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？即HashMap是如何扩容的？
先看下面程序的基本操作：

Map map = new HashMap<String,Integer>();        map.put("A",90);        map.put("B",91);        map.put("C",92);        map.put("D",92);        map.put("数学",90);        map.put("化学",87);        Set<Map.Entry> set = map.entrySet();        for(Map.Entry e: set){            System.out.println("name:" + e.getKey() + " " +"grade:" + e.getValue());        }

运行结果：

name:A grade:90name:B grade:91name:C grade:92name:D grade:92name:数学 grade:90name:化学 grade:87

下图即表示上面的数据的存储结构，这样先对Hashmap 有一个基本认识。

HashMap源码分析：

Hashmap的核心成员变量：

//HashMap的哈希桶数组，非常重要的存储结构，用于存放表示键值对数据的Node元素。transient Node<K,V>[] table;//HashMap将数据转换成set的另一种存储形式，这个变量主要用于迭代功能。transient Set<Map.Entry<K,V>> entrySet;  //HashMap中实际存在的Node数量，注意这个数量不等于table的长度，甚至可能大于它，因为在table的每个节点上是一个链表（或RBT）结构，可能不止有一个Node元素存在。transient int size;　　　　　　　　　　　　　//HashMap的数据被修改的次数，这个变量用于迭代过程中的Fail-Fast机制，其存在的意义在于保证发生了线程安全问题时，能及时的发现（操作前备份的count和当前modCount不相等）并抛出异常终止操作。transient int modCount;　　　　　　　　　　 //HashMap的扩容阈值，在HashMap中存储的Node键值对超过这个数量时，自动扩容容量为原来的二倍。int threshold;　　　　　　　　　　　　　　　　//HashMap的负载因子，可计算出当前table长度下的扩容阈值：threshold = loadFactor * table.length。 final float loadFactor;　　　　　　　　　　　

在HashMap实现了一个内部类Node

static class Node<K,V> implements Map.Entry<K,V> {　　final int hash;　　final K key;    V value;    Node<K,V> next;    Node(int hash, K key, V value, Node<K,V> next) {        this.hash = hash;        this.key = key;        this.value = value;        this.next = next;    }    public final K getKey()        { return key; }    public final V getValue()      { return value; }    public final String toString() { return key + "=" + value; }    public final int hashCode() {        return Objects.hashCode(key) ^ Objects.hashCode(value);    }    public final V setValue(V newValue) {        V oldValue = value;        value = newValue;        return oldValue;    }    public final boolean equals(Object o) {        if (o == this)            return true;        if (o instanceof Map.Entry) {            Map.Entry<?,?> e = (Map.Entry<?,?>)o;            if (Objects.equals(key, e.getKey()) &&                Objects.equals(value, e.getValue()))                return true;        }        return false;    }}

HashMap 的核心常量:

       //默认的初始容量为16，必须是2的幂次       static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;          //最大容量即2的30次方       static final int MAXIMUM_CAPACITY = 1 << 30;       //默认加载因子       static final float DEFAULT_LOAD_FACTOR = 0.75f;       //当put一个元素时，其链表长度达到8时将链表转换为红黑树       static final int TREEIFY_THRESHOLD = 8;       //链表长度小于6时，解散红黑树       static final int UNTREEIFY_THRESHOLD = 6;       //默认的最小的扩容量64，为避免重新扩容冲突，至少为4 * TREEIFY_THRESHOLD=32，即默认初始容量的2倍       static final int MIN_TREEIFY_CAPACITY = 64;

1、put()过程解析

//put()函数public V put(K key, V value) {        //调用putVal()函数        //并计算key的哈希值        return putVal(hash(key), key, value, false, true);}

static final int hash(Object key) {        int h;        //计算key的哈希值，在这里将hashCode()计算结果的        //高位与低位做异或运算以后，作为哈希值        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}

这里通过key.hashCode()计算出key的哈希值，然后将哈希值h右移16位，再与原来的h做异或^运算——这一步是高位运算。这样才能保证hash值所有位的数值特征都保存下来而没有遗漏，从而使映射结果尽可能的松散。最后，根据 n-1 做与操作的取模运算，便得到了table数组的索引。

//这里onlyIfAbsent表示只有在该key对应原来的value为null的时候才插入，     // 也就是说如果value之前存在了，就不会被新put的元素覆盖。     //evict参数用于LinkedHashMap中的尾部操作，这里没有实际意义。    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {        Node<K,V>[] tab; //定义变量tab是将要操作的Node数组引用，        Node<K,V> p; //p表示tab上的某Node节点，        int n, i;//n为tab的长度，i为tab的下标。　        //判断当table为null或者tab的长度为0时，        //即table尚未初始化，此时通过resize()方法得到初始化的table        //这种情况是可能发生的，HashMap的注释中提到：        //The table, initialized on first use, and resized as necessary。　　　　　　　　　　　　　　　　　　        if ((tab = table) == null || (n = tab.length) == 0)        n = (tab = resize()).length;        //此处通过（n - 1） & hash 计算出的值作为tab的下标i，        //并另p表示tab[i]，也就是该链表第一个节点的位置。并判断p是否为null。        //当p为null时，表明tab[i]上没有任何元素，那么接下来就new        //第一个Node节点，调用newNode方法返回新节点赋值给tab[i]。　　　　　　　　　　　　　　　　　　　　　　　　        if ((p = tab[i = (n - 1) & hash]) == null)            tab[i] = newNode(hash, key, value, null);            //下面进入p不为null的情况，有三种情况：            //第一种：p为链表节点；            //第二种：p为红黑树节点；            //第三种：p是链表节点但长度为临界长度TREEIFY_THRESHOLD，再插入任何元素就要变成红黑树了。　　　　　　　　　　　　　　　　        else {            Node<K,V> e;//定义e引用即将插入的Node节点，并且下文可以看出 k = p.key。            K k;                //HashMap中判断key相同的条件是key的hash相同，并且符合equals方法。                //这里判断了p.key是否和插入的key相等，如果相等，则将p的引用赋给e。                //这一步的判断其实是属于一种特殊情况，即HashMap中已经存在了key，                //于是插入操作就不需要了，只要把原来的value覆盖就可以了。                //这里为什么要把p赋值给e，而不是直接覆盖原值呢？答案很简单，                //现如果第一个节点就是就跟要插入的节点相同，赋值给e　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　            if (p.hash == hash &&               ((k = p.key) == key || (key != null && key.equals(k))))            e = p;                //现在开始了第一种情况，p是红黑树节点，那么肯定插入后仍然是红黑树节点，                //所以我们直接强制转型p后调用TreeNode.putTreeVal方法，返回的引用赋给e                //你可能好奇，这里怎么不遍历tree看看有没有key相同的节点呢？其实，                // putTreeVal内部进行了遍历，存在相同hash时返回被覆盖的TreeNode，否则返回null。　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　            else if (p instanceof TreeNode)                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);                //接下里就是p为链表节点的情形，也就是上述说的另外两类情况：                //插入后还是链表/插入后转红黑树。另外，上行转型代码也说明了TreeNode是Node的一个子类。            else {                //我们需要一个计数器来计算当前链表的元素个数，并遍历链表，                //binCount就是这个计数器。                for (int binCount = 0; ; ++binCount) {                    //遍历过程中当发现p.next为null时，说明链表到头了，                    //直接在p的后面插入新的链表节点，即把新节点的引用赋给p.next，                    //插入操作就完成了。注意此时e赋给p。                    if ((e = p.next) == null) {                        //最后一个参数为新节点的next，这里传入null，                        // 保证了新节点继续为该链表的末端。                        p.next = newNode(hash, key, value, null);                        ////插入成功后，要判断是否需要转换为红黑树，                        // 因为插入后链表长度加1，而binCount并不包含新节点，                        // 所以判断时要将临界阈值减1。                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st                            //当链表长度大于8时，调用treeifyBin方法，将该链表转换为红黑树。　　                              treeifyBin(tab, hash);                        //当然如果不满足转换条件，那么插入数据后结构也无需变动，                        // 所有插入操作也到此结束了，break退出即可。                        break;                     }                    //在遍历链表的过程中，我之前提到了，有可能遍历到与插入的key相同的节点，                    //此时只要将这个节点引用赋值给e，最后通过e去把新的value覆盖掉就可以了。                    //老样子判断key的哈希值并且满足equals()方法                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))                    //找到了相同key的节点，那么插入操作也不需要了，直接break退出循环进行最后的value覆盖操作。                        break;                    //前面提到过，e是当前遍历的节点p的下一个节点，                    // p = e 就是依次遍历链表的核心语句。每次循环时p都是下一个node节点。                    p = e;                }            }            //左边注释为jdk自带注释，说的很明白了，针对已经存在key的情况做处理。            if (e != null) { // existing mapping for key                V oldValue = e.value;//定义oldValue，即原存在的节点e的value值。                //前面提到，onlyIfAbsent表示存在key相同时不做覆盖处理，                //这里作为判断条件，可以看出当onlyIfAbsent为false或者oldValue为null时，进行覆盖操作                if (!onlyIfAbsent || oldValue == null)。                e.value = value;//覆盖操作，将原节点e上的value设置为插入的新value。                //这个函数在hashmap中没有任何操作，是个空函数，他存在主要是为了                //linkedHashMap里面的一些后续处理工作。                afterNodeAccess(e);                //这里很有意思，他返回的是被覆盖的oldValue。我们在使用put方法时很少用他的返回值                //，甚至忘了它的存在，这里我们知道，他返回的是被覆盖的oldValue。                return oldValue;            }        }        //收尾工作，值得一提的是，对key相同而覆盖oldValue的情况，在前面已经return，        //不会执行这里，所以那一类情况不算数据结构变化，并不改变modCount值。        ++modCount;        //同理，覆盖oldValue时显然没有新元素添加，除此之外都新增了一个元素，        //这里++size并与threshold判断是否达到了扩容标准。        if (++size > threshold)        resize(); //当HashMap中存在的node节点大于threshold时，hashmap进行扩容。        //这里与前面的afterNodeAccess同理，是用于linkedHashMap的尾部操作，HashMap中并无实际意义。1        afterNodeInsertion(evict);        return null;//最终，对于真正进行插入元素的情况，put函数一律返回null。    }

在putVal()中有resize()函数，也就是HashMap的扩容机制，扩容后大小为原来的2倍，这也是table容量为什么是2的指数次幂的原因。

final Node<K,V>[] resize() {        Node<K,V>[] oldTab = table; // oldTable:当前的表        int oldCap = (oldTab == null) ? 0 : oldTab.length;  //如果你是新创建的话 表的大小就是0 否则就是原来的大小        //第一次是为0的    代表 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16        int oldThr = threshold;             int newCap, newThr = 0; //新的容量和新的扩容        //如果旧的容量大于0        if (oldCap > 0) {        //如果旧的容量大于最大的容量            if (oldCap >= MAXIMUM_CAPACITY) {               //那么扩容大小 = 最大范围                threshold = Integer.MAX_VALUE;              //直接返回了                return oldTab;              }        //否则 如果新的大小等于 oldCap * 2 < 最大的容量 ， 并且旧的容量大于默认的初始化大小16            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                     oldCap >= DEFAULT_INITIAL_CAPACITY)     // double threshold  新的扩容 = 旧的扩容 * 2                 newThr = oldThr << 1;        }        else if (oldThr > 0) // initial capacity was placed in threshold             newCap = oldThr;    //如果旧的扩容本来就大于0，那么新的容量就是旧的扩容        else {               // zero initial threshold signifies using defaults 说明是 threshold为0的时候的情况            newCap = DEFAULT_INITIAL_CAPACITY;      //新的容量为默认容器的容量            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //新的阙值为 默认的容量 * 负载因子        }           if (newThr == 0) {  //如果新的扩容为0             float ft = (float)newCap * loadFactor;  //计算得到新的阙值        //新的阙值 =  如果新的容量小于 最大的容量 并且 新的阙只 < 最大的容量 那么新的阙值 = 计算的 否则 = 最大int            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; //         if (oldTab != null) {    //遍历旧的hash桶        for (int j = 0; j < oldCap; ++j) {                  Node<K,V> e;                    if ((e = oldTab[j]) != null) {//如果旧的hash桶的元素不为null  e为旧的hash桶的元素                    oldTab[j] = null;   //旧的hash桶设置为null                    if (e.next == null)     //如果你就是一个元素                        newTab[e.hash & (newCap - 1)] = e;  //那么在新的hash桶给你安排一个位置  位置是你的hash值 & 新的桶的容量-1 这相当于 你的hash值 与 你的容量进行取模运算                    else if (e instanceof TreeNode) //如果你不只一个元素并且是TreeNode                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);//分割  将树中的节点 分割到高位或者地位上去                      else { // 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;    }

接着看下一篇：JDK源码学习之HashMap扩容机制resize()