HashMap源码解析

1、HashMap的数据结构
在1.7版本 数组+链表
在1.8版本 数组+链表+红黑树

先看看hashMap在jdk 1.8的结构，如下图，用的是数组+链表+红黑树的结构，也叫哈希桶，在jdk 1.8之前都是数组+链表的结构，因为在链表的查询操作都是O(N)的时间复杂度，而且hashMap中查询操作也是占了很大比例的，如果当节点数量多，转换为红黑树结构，那么将会提高很大的效率，因为红黑树结构中，增删改查都是O(log n)。

图片来源网络，侵删
1、HashMap中的相关属性

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    //序列号，序列化的时候使用。
    private static final long serialVersionUID = 362498820763181265L;
    /**默认容量，1向左移位4个，00000001变成00010000，也就是2的4次方为16，使用移位是因为移位是计算机基础运算，效率比加减乘除快。**/
    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;
    //当某个桶节点数量大于8时，会转换为红黑树。
    static final int TREEIFY_THRESHOLD = 8;
    //当某个桶节点数量小于6时，会转换为链表，前提是它当前是红黑树结构。
    static final int UNTREEIFY_THRESHOLD = 6;
    //当整个hashMap中元素数量大于64时，也会进行转为红黑树结构。
    static final int MIN_TREEIFY_CAPACITY = 64;
    //存储元素的数组，transient关键字表示该属性不能被序列化
    transient Node<K,V>[] table;
    //将数据转换成set的另一种存储形式，这个变量主要用于迭代功能。
    transient Set<Map.Entry<K,V>> entrySet;
    //元素数量
    transient int size;
    //统计该map修改的次数
    transient int modCount;
    //临界值，也就是元素数量达到临界值时，会进行扩容。
    int threshold;
    //也是加载因子，只不过这个是变量。
    final float loadFactor; 

2、HashMap的构造方法
（1）没有指定HashMap数组的长度的话，它会以默认的长度定义一个数组

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

（2）指定了HashMap数组的长度的话，它会通过指定的长度构建一个数组，但是它会通过tableSizeFor（）方法，将我们给定的大小转换为一个2的指数。（因为2的幂-1都是11111结
尾的，所以碰撞几率小。）

public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

 static final int tableSizeFor(int cap) {
        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;
    }

3、HashMap中put方法的过程

（1）HashMap底层是通过数组实现的，那么我们怎么确定put的元素对应下标的位置呢？
源码是通过 ： key.hash &（数组长度-1）来确定下标的

  if ((p = tab[i = (n - 1) & hash]) == null)
          tab[i] = newNode(hash, key, value, null);

举个例子：
因为hash是int型的，转换为二进制的话，是32为的，例如：01010101010101010101010101010101
数组默认长度为16，（16-1）转换为二进制为：
01111
01111&10101=5，这就确定了下标的位置

确定下标后还需要考虑保证HashMap的读取效率，方法之一：

 static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

这个方法就是将高16为与低16位进行异或运算，这样就能保证 key.hash &（数组长度-1）的值尽可能的不一样（使得造成分布不均匀，增加碰撞的几率，减慢了查询的效率，造成空间的浪费的问题发生的可能性更小 ）

（2）确定下标后判断当前位置是否为空，空的话直接放入节点，不为空就需要通过节点的key值判断是否碰撞(key值是否相等)，如果有的话，就用当前节点去替换旧的节点，没有的话就以链表的方式连接到后面。
（3）当链表的长度超过阈值（ TREEIFY_THRESHOLD = 8）时，就会把链表转换为红黑树以提高HashMap的读取效率，因为红黑树是绝对平衡的一种二叉树，遍历效率最高
（4）如果桶满了（size>容量*加载因子），就需要扩容，问题来了，应该怎么扩容呢？扩容后原来数组的数据怎么处理呢？

if (++size > threshold)
            resize();

4、HashMap的扩容方式
（1）就是将原来的数组长度<<1,也就是，原数组长度x2

   else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1;

（2）扩容后需要将老数组数据移动到新数组

先遍历老数组的元素，保证数组下标位置不为空，就是在有元素的前提下进行处理，分为以下三种情况：
a.数组对应下标是一个节点
b.数组对应下标是一个链表
c.数组对应下标是一棵红黑树

a的处理方法：节点的hash&(新数组长度-1)
c的处理方法: 通过split的方法将红黑树切分，在进行处理（这里就不在细说了）
b的处理方法： 节点的hash&原数组的长度

样做的目的是判断原来hash二进制的倒数第（原数组长度二进制的位数）是为1还是0，若是0的话，位置保持不变，若不是0，原来的位置+原数组的长度
01010101010101010101010101010101
00000000000000000000000000010000

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