HashMap源码分析

源码分析

基于JDK1.8

4个构造函数

HashMap()

//1. 无参构造
/**
 * Constructs an empty <tt>HashMap</tt> with the default initial capacity
 * (16) and the default load factor (0.75).
 */
//构造一个空的HashMap,初始容量为16，负载因子是0.75
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; 
}

//负载因子默认为0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;

负载因子，代表了table的填充度有多少，默认是0.75 加载因子存在的原因，还是因为减缓哈希冲突，如果初始桶为16，等到满16个元素才扩容，某些桶里可能就有不止一个元素了。 所以加载因子默认为0.75，也就是说大小为16的HashMap，到了第13个元素，就会扩容成32。

HashMap(int initialCapacity)

//创建一个初始容量为initialCapacity，负载因子为0.75的HashMap
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

HashMap(int initialCapacity, float loadFactor)

//构造一个空的初始容量为initialCapacity，负载因子为loadFactor的HashMap
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);
}

//最大容量（1 << 30 也就是2的30次方）
static final int MAXIMUM_CAPACITY = 1 << 30;

这里为什么是2的30次方，请看这篇博客！

设定threshold。这个threshold=capacity * loadFactor。当HaspMap的size到了threshold，就会进行resize,也就是扩容。

tableSizeFor()的主要功能是返回一个比给定整数大且最接近2的幂次方整数，如给定10，返回2的4次方16。

找到tableSizeFor(int cap)的源码：

/**
 * Returns a power of two size for the given target capacity.
 */
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;
}

根据上面给的那个如cap为10。看一下运算过程！

HashMap(Map<? extends K, ? extends V> m)

//构造一个和制定Map有相同mappings的HashMap，初始容量能充足的容下指定的Map,负载因子为0.75
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}

直接看putMapEntries(m, false)。源码如下：

//将m的所有元素存入本HashMap实例中
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
	//得到m中的元素个数
    int s = m.size();
    //当m中有元素时，则需要将map中元素放入本HashMap实例
    if (s > 0) {
    	//判断table是否已初始化，如果未初始化，则先初始化一些变量。（table初始化是在put时）
        if (table == null) { // pre-size
        	//根据待插入的map的size计算要创建的 HashMap 的容量
            float ft = ((float)s / loadFactor) + 1.0F;
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                     (int)ft : MAXIMUM_CAPACITY);
            //把要创建的HashMap 的容量存在 threshold中
            if (t > threshold)
                threshold = tableSizeFor(t);
        }
        //进行扩容
        else if (s > threshold)
            resize();
        //然后就开始遍历 插入的map，将每一个<key, value>插入到本HashMap实例中
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
            K key = e.getKey();
            V value = e.getValue();
            //put(K,V)也是调用putVal 方法进行元素的插入
            putVal(hash(key), key, value, false, evict);
        }
    }
}

putMapEntries方法中，如果table为null，那么这时就设置合适的threshold，如果不为空并且指定的map的size > threshold，那么就resize()，然后把指定的map中的所有key,value，通过putVal添加到我们创建的新的map中。

那咱们先看一下hash(key)。

/**
* key 的hash值的计算是通过hashcode()的高16位与低16位做异或实现的：
* (h = key.hashCode()) ^ (h >>> 16)
*/

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

public native int hashCode();

异或运算：(h = key.hashCode()) ^ (h >>> 16)

原来的hashcode: 1111 1111 1111 1111 0100 1100 0000 1010

移位后的hashcode: 0000 0000 0000 0000 1111 1111 1111 1111

进行异或运算 结果： 1111 11111 1111 1111 1011 0011 1111 0101

这样做的好处是：可以将hashcode高位和低位的值进行混合做异或运算，而且混合后，低位的信息中加入了高位的信息，这样高位的信息被变相的保留了下来。参杂的元素多了，那么生成的hash值的随机性会增大。

再来看一下resize() 方法。

/**
 * Initializes or doubles table size.  If null, allocates in
 * accord with initial capacity target held in field threshold.
 * Otherwise, because we are using power-of-two expansion, the
 * elements from each bin must either stay at same index, or move
 * with a power of two offset in the new table.
 *
 * @return the table
 */
final Node<K,V>[] resize() {
    //保存当前table
    Node<K,V>[] oldTab = table;
    //保存当前table的容量
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //保存当前阈值
    int oldThr = threshold;
    //初始化新的table容量和阈值
    int newCap, newThr = 0;
    /*
    1. resize() 方法在size > threshold时被调用。oldCap大于0 代表原来的table非空，
    	oldCap为原表的大小， oldThr（threshold）为 oldCap * load_factor
    */
    if (oldCap > 0) {
        //若旧table容量已超过最大容量，更新阈值为Integer.MAX_VALUE，这样以后不会自动扩容了
        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
    }
    /*
    2. resize() 函数在table为空被调用。oldCap 小于等于0且oldThr 大于0，代表用户
    创建了一个HashMap。但是使用的构造函数为HashMap(int initialCapacity) 或
    HashMap(int initialCapacity, float loadFactor) 或  HashMap(Map<? extends K, ? extends V> m)，导致oldTab为null，oldCap为0，oldThr为用户指定的HashMap的初始容量
    */
    else if (oldThr > 0) // initial capacity was placed in threshold
        //当table没初始化时，threshold持有初始容量。
        newCap = oldThr;
    /*
    3. resize()函数在table为空被调用。oldCap 小于等于0且oldThr 等于0。
    用户调用HashMap()构造函数创建的HashMap，所有值均采用默认值，oldTab(Table)为空，oldCap为0，oldThr为0
    */
    else {               // zero initial threshold signifies using defaults
        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"})
    //初始化table
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        //把oldTab中的节点，reHash 到newTab中去
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                //若节点是单节点，直接在newTab中进行重定位
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                //若节点是TreeNode节点，要进行红黑树的rehash操作
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                //若是链表，进行链表的rehash操作
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    //将同一桶中的元素根据(e.hash & oldCap)是否为0进行分割
                    do {
                        next = e.next;
                        //根据算法，(e.hash & oldCap) 判断节点位置rehash后是否发生改变
                        //最高位==0，这是索引不变的链表
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        //最高位为1，这是索引发生改变的链表
                        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;
                        //rehash 后节点新的位置一定为原来基础上加上oldCap
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

这里使用的是2次幂的扩展，指长度扩为原来的2倍。所以，元素的位置要么是在原来的位置，要么是在原本位置上再移动2次幂的位置。

如下图，n 为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。
这里加一一个方法，在jdk1.7里面有，1.8中没有，但是实现原理是一样的。

static int indexFor(int h, int length) {  //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的  
    return h & (length-1); 
} 

确定索引位置的例子你就能看懂了。
key的hash值与n-1做& 运算。

元素在重新计算hash之后，因为n变为2倍，那么n-1 的mask范围在高位多1bit（红色）。因此新的index会发生这样的变化:

因此，在扩充HashMap的时候，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引就变为”原来的索引+ oldCap“ 。

什么时候扩容：通过上述源码可以看到是在put操作时，即向容器中添加元素时，判断当前容器中的元素的个数是否达到阈值的时候，就要自动扩容了。

再最后看一下putVal的源码：

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为空或者长度为0，则resize()
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //确定插入table的位置，算法是(n - 1) & hash，在n为2的幂时，相当于取模操作
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    //在table的i位置发生碰撞，有两种情况：
    //1. key一样，替换value
     //2. key不一样，有两种处理方法：存储在i位置的链表中，存储在红黑树中
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //不是TreeNode，即为链表，遍历链表
            for (int binCount = 0; ; ++binCount) {
                //链表的尾端也没有找到key值相同的节点，则生成一个新的node
                //并且判断链表的节点个数是不是到达转换成红黑树的上界，到达则转换红黑树
                if ((e = p.next) == null) {
                    //创建链表节点并插入 尾部
                    p.next = newNode(hash, key, value, null);
                    //超过了链表的设置长度8就转成红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

static final int TREEIFY_THRESHOLD = 8;

附：

参考： https://www.jianshu.com/p/ee0de4c99f87

最后一张图： https://blog.csdn.net/woshimaxiao1/article/details/83661464