Java还要再学一遍基础（九）HashMap原理

HashMap概述

HashMap是用于存储映射(键值对)的数据类型，允许key为null，同时不保证插入顺序的一个非同步的数据类型。但是在非同步的java的程序中HashMap的使用非常的频繁，需要同步的情况可以使用ConcurrentHashMap。本文基于JDK1.8(hash算法改变和引入红黑书等)做阐述。重点研究HashMap的hash算法，put方法（如何解决哈希冲突），和当HashMap需要扩容的时候的处理等。

---

HashMap详解

1. 重要的属性

//默认容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量为2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的加载因子为0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表的阈值
static final int TREEIFY_THRESHOLD = 8;
//存储键值对的数组
transient Node<K,V>[] table;
//已经存储了的键值对数
transient int size;
//可以允许的存储的键值对的个数
int threshold;
//加载因子
final float loadFactor;

• 加载因子的作用：threshold = size*loadFactor, 而当存储的键值对的个数大于了threshold，那么就需要进行扩容， HashMap扩容的量是扩容后的容量为原来的两倍。同时默认的加载因子是0.75，一般不建议修改，这是官方对于时间和空间的权衡得出的一个比较平衡的值，在没有特殊情况下一般不需要修改。

---

2. Node

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;

    //......

    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }
}

//Objects中的hashCode方法
    public static int hashCode(Object o) {
        return o != null ? o.hashCode() : 0;
    }

可以看到Node节点除了存放基本的键值对key和value，同时还存放了一个hash值，和一个指向下一个借点的next，同时Override了hashCode（）方法，而且其中调用了对应的键值对的对象的hashCode方法，也就是说在使用HashMap的时候，传入的对象的hashCode方法大很大程度上影响了HashMap的性能（对发生哈希冲突的可能性的影响）。

---

3. 构造方法

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);
}
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}

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

重点关注第一个构造方法，其中确定threshold的时候调用了tableSizeFor方法，这个方法是保证容量为大于等于16且2的倍数的数。比如initialCapacity为17，那么就应该返回32。其中的>>>表示无符号右移。

以initialCapacity=30位例子，
int n = cap - 1;//n=29 也就是0000 0000 0001 1101

 /*
    0000 0000 0001 1101    n |= n >>> 1;
    0000 0000 0000 1110
    --------------------
    0000 0000 0001 1111    n |= n >>> 2;
    0000 0000 0000 0111
    --------------------
    0000 0000 0001 1111    n |= n >>> 4;
    0000 0000 0000 0001
    --------------------
    0000 0000 0001 1111    n |= n >>> 8;
    0000 0000 0000 0000
    -------------------
    0000 0000 0001 1111   //后面同理
 */

最后总能得到一个2的倍数。

---

4. hash方法

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

这里的hash值的计算使用的是对象原来的hashCode的h和h的高16位做异或运算。
同时在确定位置的时候使用的的是：

tab[i = (n - 1) & hash]

这里的tab就是键值对数组table，hash是上面计算后的hash值。n是size。
假设key.hashCode()返回1111 1111 0101 1010 0000 1011 0110 0001，size是32

//(h = key.hashCode()) ^ (h >>> 16)
/*
    1111 1111 0101 1010 0000 1011 0110 0001    h
    0000 0000 0000 0000 1111 1111 0101 1010    h >>> 16
    ----------------------------------------
    1111 1111 0101 1010 1111 0100 0011 1011
*/
//(n - 1) & hash
/*
    0000 0000 0000 0000 0000 0000 0001 1111   n - 1
    1111 1111 0101 1010 1111 0100 0011 1011   hash
    ----------------------------------------
    0000 0000 0000 0000 0000 0000 0001 1011
*/

最后结果27.
当n总是2的倍数的时候这里的hash运算结合上（n-1）&hash的结果其实是和hash % n是等价的，但是这里的位运算的效率比起直接取模更加高一些，同时保证了高16位也参与了hash运算，同时不会有太大的开销，而且在n相对比较小的时候也不会有太大的开销。

---

4. put方法

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


final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //当数组为空或者长度为0就初始化数组。
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //通过hash值计算出一个位置i，如果tab[i]为空则说明没有发生哈希冲突，直接插入
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    //发生哈希冲突
    else {
        Node<K,V> e; K k;
        //如果i位置处的key就是要插入的key那么纪录这个节点e
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            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) {
                //如果遍历到第binCount+1个节点的next为空，则在其后插入新的节点
                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;
                }
                //如果在链表中遍历到相同的key值则直接退出循环
                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;
    //如果size超过了允许的容量，执行resize操作
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

上述代码可以基本上看的出HashMap中插入键值对的时候的逻辑。
红黑树转换：

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    //如果数组为空或者size为0那么执行初始化操作
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    //遍历tab[i]所在的链表并将其转换成红黑树
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        //hd，tl分别代表head，tail
        TreeNode<K,V> hd = null, tl = null;
        do {
            //replacementTreeNode只是简单调用TreeNode的构造函数返回一个对象
            TreeNode<K,V> p = replacementTreeNode(e, null);
            //最开始直接将hd指向p
            if (tl == null)
                hd = p;
            //依次的链接
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        //实际上上面的代码只是将Node<>节点的链表转换成了TreeNode<>的链表，真正的红黑树的转换在treeify方法
        //红黑书的相关知识可以网上参考红黑树的介绍。
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

转换成红黑书的基本思路是：Node节点构成的链表全部换成TreeNode节点的链表，然后再将其转换成红黑树的结构。

5. resize方法
resize方法决定了HashMap的扩容。

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    //如果oldCapacity大于0
    if (oldCap > 0) {
        //边界处理
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //newCapacity为如果oldCapacity左移1位，也就是原来的两倍
        //newThreshold也是同理，原来的两倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    //如果oldCap为0并且oldThreshold大于0
    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) {
        //这里可以看到threshold的值为capacity*loadFactor
        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;
    //将原来的数组中的元素移动到新的数组中
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                //oldTab[j] = null;释放空间
                oldTab[j] = null;
                //如果当前节点下面没有链表或者说没有发生过哈希冲突那么直接根据新的容量计算index赋值
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                //当前节点是红黑树，则调用split方法
                else if (e instanceof 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;
                        //判断高位是否为0
                        //0的情况则e在新的数组的index和原来相同，否则index为oldCap + j（j为原来的index）
                        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);
                    //高位是否为0
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    //高位是否为1
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

其中最值得研究的就是关于高位为0还是为1的问题，因为扩容的容量是变为原来的两倍，在JDK1.8以前的resize方法是重新去计算每个key的hash值去确定位置，这样效率很低，而现在则是判断高位是否为0之后直接确定位置并赋值，省去了非常多的hash计算。
例如：原来的size是16，有两个元素的hash分别为3，20，也就是说在index为3和4的位置，扩容之后size变为32这个时候的index就分别变为了3（不变），20（4 + 16）。
因为上面讲到根据hash值计算index的逻辑是（n - 1）& hash得出的，那么上面的例子的实际处理：

//当n为16的时候
/*
    0000 0000 0000 0000 0000 0000 0000 1111     n -1
    0000 0000 0000 0000 0000 0000 0000 0011     hash=3
    -----------------------------------------
    0000 0000 0000 0000 0000 0000 0000 0011     结果为3

    0000 0000 0000 0000 0000 0000 0000 1111     n -1
    0000 0000 0000 0000 0000 0000 0001 0100     hash=20
    -----------------------------------------
    0000 0000 0000 0000 0000 0000 0000 0100     结果为4
*/

//当n为32的时候
/*
    0000 0000 0000 0000 0000 0000 0001 1111     n -1
    0000 0000 0000 0000 0000 0000 0000 0011     hash=3
    -----------------------------------------
    0000 0000 0000 0000 0000 0000 0000 0011     结果为3

    0000 0000 0000 0000 0000 0000 0001 1111     n -1
    0000 0000 0000 0000 0000 0000 0001 0100     hash=20
    -----------------------------------------
    0000 0000 0000 0000 0000 0000 0001 0100     结果为20
*/

所以直接判断这里的高位，也就是因为扩容而相比原来多出的一位的位置上为0还是1便可以判断在新的数组中的位置。
同时e.hash & oldCap：

//n为16
/*
    0000 0000 0000 0000 0000 0000 0001 0000     n
    0000 0000 0000 0000 0000 0000 0000 0011     e.hash=3
    -----------------------------------------
    0000 0000 0000 0000 0000 0000 0000 0000    高位为0

    0000 0000 0000 0000 0000 0000 0001 0000     n
    0000 0000 0000 0000 0000 0000 0001 0100     e.hash=20
    -----------------------------------------
    0000 0000 0000 0000 0000 0000 0001 0000     高位为1
*/

这样一看便非常的清楚了。

HashMap的特性总结

• 存储键值对，并且键是唯一的，不能重复。
• 允许键为null
• 不保证元素的有序性。（插入顺序）
• 线程不安全。
• 使用双向链表解决哈希冲突问题
• JDK1.8加入红黑书提高了性能
• 默认加载因子为0.75（没有特殊要求不用更改）