HashMap源码解析

本来我是准备要先看HashSet的源码，但是发现HashSet内部的实现全是由HashMap实现的，所以我觉得看完HashMap再看HashSet会更容易理解一点。
我们先来看看官方给出的HashMap的解释：

哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

HashMap 的实例有两个参数影响其性能：初始容量 和加载因子。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。

通常，默认加载因子 (.75) 在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。

虽然有点多，但是我觉得都挺重要的，下面配合这源码分析来理解上述的话，可能要好一点，下面我们先来看一下存储的示意图，图是我盗来的哈哈。

图中的table是map的主要存储中心，它是一个数组。table数组中的每一个元素被称为桶（bucket），也就是说table[index]就是一个桶。桶中的元素是一个时，相当于数组table的一项（也可以理解是链表的头结点），当桶中的元素是2-7个时，桶的数据结构则变成链表。大于等于8个时，Java1.8做的优化，引入了红黑树进行存储。

-HashMap定义

public class HashMap<K,V> extends AbstractMap<K,V>    implements Map<K,V>, Cloneable, Serializable 

HashMap成员变量

    //默认桶容量    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16    //最大容量    static final int MAXIMUM_CAPACITY = 1 << 30;    //默认的填充因子    static final float DEFAULT_LOAD_FACTOR = 0.75f;    //一个桶中存放的元素个数大于或等于这个数值就会转化成红黑树来存储    static final int TREEIFY_THRESHOLD = 8;    //当一个桶上的红黑树的结点个数小于这个值时，树转换成链表    static final int UNTREEIFY_THRESHOLD = 6;    //hash 冲突的链表转变为红黑树时，需要判断下此时数组容量，若是由于数组容量太小（小于　MIN_TREEIFY_CAPACITY　）导致的 hash 冲突太多，则不进行链表转变为红黑树操作，转为利用　resize() 函数对　hashMap 扩容    static final int MIN_TREEIFY_CAPACITY = 64;    //存放的桶的数组    transient Node<K,V>[] table;    // 存放具体元素的集    transient Set<Map.Entry<K,V>> entrySet;    //存放元素的个数    transient int size;    //记录扩容和更改map的记录器    transient int modCount;    //阈值，当实际大小超过这个值时，会扩容    int threshold;    //填充因子    final float loadFactor;

-内部类

最重要的内部类就是定义结点的内部类

static class Node<K,V> implements Map.Entry<K,V> {        final int hash;//结点的hash值        final K key;//key值        V value;//vaule值        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; }    //一个结点的hash值是key和value分别取hash再做异或运算        public final int hashCode() {            return Objects.hashCode(key) ^ Objects.hashCode(value);        }        //value赋值就是新值替换旧值        public final V setValue(V newValue) {            V oldValue = value;            value = newValue;            return oldValue;        }        //对比两个note是否相等        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;        }    }

-构造函数
//无参数构函，填充因子是默认的填充因子也就是0.75

public HashMap() {        this.loadFactor = DEFAULT_LOAD_FACTOR;        defaulted}

//指定容量的构函，直接调用指定容量，指定填充因子的构函，但是默认填充因子0.75作为参数直接传了过去 public HashMap(int initialCapacity) {        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }

    //用指定容量，指定填充因子的构函    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);    }

下面我们来看tableSizeFor（）这个方法。

   //这个方法所做的就是返回一个最接近指定数的2的n次幂，但是返回的一定是大于或等于指定数的，例如传进来是17，会返回32.   static final int tableSizeFor(int cap) {        //方法的核心就是把指定数二进制每一位都变成1，最后加1，就变成上述数据，具体的算法解析[我的ArrayDeque循环队列的部分源码分析中有](http://blog.csdn.net/qq_35357656/article/details/76254186)        int n = cap - 1;        n |= n >>> 1;        n |= n >>> 2;        n |= n >>> 4;        n |= n >>> 8;        n |= n >>> 16;        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;    }

   //将指定map集合填充新集合   public HashMap(Map<? extends K, ? extends V> m) {        //填充因子设置为默认的0.75        this.loadFactor = DEFAULT_LOAD_FACTOR;        //调用填充的函数        putMapEntries(m, false);    }

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {        int s = m.size();//取出指定map的元素个数        if (s > 0) {            //判断table是否已经初始化过了            if (table == null) { // pre-size                //初始化阈值                float ft = ((float)s / loadFactor) + 1.0F;                int t = ((ft < (float)MAXIMUM_CAPACITY) ?                         (int)ft : MAXIMUM_CAPACITY);                //计算的阈值如果大于当前阈值就把它赋值给当前阈值                if (t > threshold)                    threshold = tableSizeFor(t);            }            //如果table已经初始化过，而且指定map集合的元素数大于阈值，那么直接扩容            else if (s > threshold)                resize();            //然后再把指定的map的元素通过遍历，假如HashMap中            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {                K key = e.getKey();                V value = e.getValue();                //具体插入的函数                putVal(hash(key), key, value, false, evict);            }        }    }

   //HashMap的核心函数之一，   final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) {        Node<K,V>[] tab; Node<K,V> p; int n, i;        //如果table还是没有初始化，直接就扩容        if ((tab = table) == null || (n = tab.length) == 0)            //扩容的tab的长度赋值给n            n = (tab = resize()).length;         //开始添加元素，如果一个桶中一个元素都没有就直接赋值给那个桶，         注意这里是table的长度-1在与hash值取与运算来决定元素放的桶的位置        if ((p = tab[i = (n - 1) & hash]) == null)         //生成新的结点，直接赋值            tab[i] = newNode(hash, key, value, null);        else {//如果对应的桶已经有结点了            Node<K,V> e; K k;            //判断已经存在的结点的key和要插入的结点的key是否相同            if (p.hash == hash &&                ((k = p.key) == key || (key != null && key.equals(k))))                //如果相同，先将要插入的结点暂时赋值给e                e = p;            //如果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);                        //如果大于或等于7了，直接把桶的结构转换成红黑树                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st                            treeifyBin(tab, hash);                        break;                    }                    //如果遍历的过程中遇到了key相同的结点，那么就跳出循环                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))                        break;                    p = e;                }            }            //这个if语句解决的是所有遇到key值相同的情况，那么就用新的value替换旧的value            if (e != null) { // existing mapping for key                V oldValue = e.value;                if (!onlyIfAbsent || oldValue == null)                    e.value = value;                afterNodeAccess(e);                return oldValue;            }        }        ++modCount;//对map的结构次数加一        if (++size > threshold)//如果元素的个数等于了阈值，那么就扩容            resize();        afterNodeInsertion(evict);        return null;    }

//扩容函数，HashMap的核心函数之二，大概瞄一眼，头晕，我们来仔细瞄一眼 final Node<K,V>[] resize() {        Node<K,V>[] oldTab = table;//先把旧table暂存一下        //取出旧table的长度        int oldCap = (oldTab == null) ? 0 : oldTab.length;        int oldThr = threshold;//取出旧的阈值        int newCap, newThr = 0;//定义新table的长度和阈值        if (oldCap > 0) {            //如果旧的table的长度直接比最大容量都大，那还扩个鸡儿容，把阈值该成最大，直接返回旧table了            if (oldCap >= MAXIMUM_CAPACITY) {                threshold = Integer.MAX_VALUE;                return oldTab;            }            //如果扩容后的值（扩容一般直接是原容器的两倍）小于最大值和旧table的长度也不小于默认容量，那么就扩容            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                     oldCap >= DEFAULT_INITIAL_CAPACITY)                newThr = oldThr << 1; // double threshold        }        //如果旧table没有初始化，但是阈值已经赋值，那么就把阈值当做新table的容量        else if (oldThr > 0)             newCap = oldThr;        else {        // oldCap = 0并且oldThr = 0，使用缺省值（如使用HashMap()构造函数，之后再插入一个元素会调用resize函数，会进入这一步）                  newCap = DEFAULT_INITIAL_CAPACITY;            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//这可以看出，阈值等于总容量*填补因子        }        //如果新阈值为0        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;//创建一个新的表        //这时要把旧表的数据导入新表了，这里采用了rehash，做法是把一个桶上的一个链表拆成两个链表，然后重新hash找桶        if (oldTab != null) {            for (int j = 0; j < oldCap; ++j) {                Node<K,V> e;                if ((e = oldTab[j]) != null) {                    //如果取出了结点，先把结点暂存在e中                    oldTab[j] = null;                    if (e.next == null)//如果桶中就一个结点                        //那么我们再hash将这个结点存入                        newTab[e.hash & (newCap - 1)] = e;                    else if (e instanceof TreeNode)                        //如果这个结点是红黑树的结点，那么将它拆成更小的树                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);                    else { //如果是链表的话，通过(e.hash & oldCap) == 0将整个链表打碎成两个链表后再hash存放                        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;    }

总结：在扩容的函数我们可以看出，扩容是一件非常消耗资源的事情，如果我们之前能大概知道我们要存入的数据的数量，尽量设置符合你需求的初始容量，以此来避免扩容。