HashMap存储原理分析

如果要了解HashMap的底层存储原理，首先要知道几个算法，也是HashMap存储的核心算法。

Hash表容量计算方法

HashMap底层维护的就是哈希表，其容量计算方法核心源码如下：

static final int tableSizeFor(int cap) {
	int n = cap - 1;//n0
	n |= n >>> 1;	//n1
	n |= n >>> 2;	//n2
	n |= n >>> 4;	//n3
	n |= n >>> 8;	//n4
	n |= n >>> 16;	//n5
	return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

cap	n0	n1	n2	n3	n4	n5	return
1	0	0	0	0	0	0	1
3	2	3	3	3	3	3	4
5	4	6	7	7	7	7	8

可以发现，输入的值无论是多少，最后都会是1、2、4、8、16，当大于16的时候，同样也是2倍递增结果。

在使用HashMap进行创建对象的时候，我们可以自定义容量。

HashMap hashMap = new HashMap(int initialCapacity);

//该方法底层源码是：
public HashMap(int initialCapacity) {
	this.threshold = tableSizeFor(initialCapacity);	//调用tableSizeFor方法计算容量
}

该构造函数调用的就是 tableSizeFor(int cap) 方法，所以，你自定义的容量最后都会被修改为1、2、4、8、16、32…

Hash值计算方法

hash值的计算方法使用的是【高16位】与其进行的异或运算，目的是使散列均匀，后面计算哈希表位置的时候不至于出现数据扎堆的情况。

核心源代码：

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

比如10 ，计算机32位存储为【0000 0000 0000 1100 0000 0000 0000 1010】，前面可能有1也有0，最后要保证是1010，【h>>>16】的操作就是右移16位，即取高16位【0000 0000 0000 1100】，
与其进行异或运算，结果就哈希值【0000 0000 0000 0110】。

插入到哈希表位置的计算方法

核心源代码：

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

tab是一个哈希表，其实就是数组，中括号内容就是索引位置，n为哈希表的容量，hash为哈希值。

假设哈希表的容量是16，则 i = 15，其二进制为1111，通过与哈希值进行【&与】运算，得到的就是哈希值的后四位，该值在哈希表的索引位置。

就拿上面的哈希值【0000 0000 0000 0110】，与15进行【&与】运算，如图：

通过这个计算方法，我们也就知道，为何哈希表容量必须是2的倍数扩增了，目的就是方便计算取位。

扩容后元素位置的处理方法（链表拆分）

核心源代码：

//e.hash为元素的哈希值，oldCap为旧容量大小
(e.hash & oldCap) == 0;

//原位存储
newTab[j] = loHead;

//重新分配位置存储
newTab[j + oldCap] = hiHead;

比如，在容量为8的哈希表中存储有2、4、10、12四个元素，他们的哈希值经过运算也是2、4、10、12，通过前的方法，我们可以计算它们在容量为8的哈希表中的位置，即【2、4、2、4】 。

现在容量为扩增为16，这时候需要将表中的存有的哈希值进行源代码中的运算，即【e.hash & oldCap】。

比如2，与之前的8进行与运算，结果为0，表示，2所在位置不变，还是原位存储。

比如10，与之前的8进行与运算，结果为8(1000)，不是0，则需要重新计算位置，但是其位置也是有规律的，10如果在容量为16的哈希表中，其位置是10，在容量为8的哈希表中，位置是2，差8，刚好为【原位置 + 旧容量】，所以在源代码中是【j + oldCap】。

源码分析

//HashMap源码
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;	//默认容量为16
static final int MAXIMUM_CAPACITY = 1 << 30;	//最大容量2^30次幂
static final float DEFAULT_LOAD_FACTOR = 0.75f;//阈值率默认0.75，超过阈值，自动扩容
final float loadFactor;	//自定义阈值率
static final int TREEIFY_THRESHOLD = 8;	//链表转树的条件，链表节点超过8
static final int UNTREEIFY_THRESHOLD = 6;//树转链表条件，树节点个数低于6
static final int MIN_TREEIFY_CAPACITY = 64;//转树的第二条件，桶个数超过64个
transient Node<K,V>[] table;

/**
*自定义容量和阈值率
*/
public HashMap(int initialCapacity, float loadFactor) {
	this.loadFactor = loadFactor;
	this.threshold = tableSizeFor(initialCapacity);	//调用tableSizeFor方法计算容量
}

/**
*tableSizeFor方法计算容量方法
*当输入1-->n=0-->0位运算都是0-->然后与n进行或运算，结果都是0，最后输出结果为1
*当输入3-->n=2-->2第一次位运算结果为1，再与n(2)或运算，结果n为3(11)，与任何数字或运算都是3，最后结果4
*最后结果都会是1111...，最后+1结果都是1，2，4，8，16，32...
*/
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;
}

//this()方法也是tableSizeFor方法
public HashMap(int initialCapacity) {
	this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/**
*计算hash值，将key值的hashCode()与其高位(int类型32位，右移16取高位)进行异或运算，使散列均匀
*/
static final int hash(Object key) {
	int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}


//put方法，调用的是putVal方法
public V put(K key, V value) {
	return putVal(hash(key), key, value, false, true);
}

//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;
	if ((tab = table) == null || (n = tab.length) == 0)
        
        /**
        *resize()扩容方法，2的倍数扩容
        *扩容后进行元素的复制和重新归位，比如16扩容到32，此时i = 31(11111)，和元素的hash值进行与运
        *算找元素位置，如果元素的hash是01001，则异或后还是01001，位置不动，所以该方法可以节约时间
        */
	    n = (tab = resize()).length;
    
    /**
    *这里根据该元素的hash值确定其在哈希表的位置，比如，现在hash表容量为16,i = 15(1111),通过与hash值进
    *行与运算，得到了hash的后四位，就是tab[]表中位置
    *如果输入的key和value两者的hash在表中位置为空，表示没元素，则直接放入元素
    *这里还对p进行了初始化，为该桶的第一个节点地址，用于后面的循环遍历
    */
	if ((p = tab[i = (n - 1) & hash]) == null)
	    tab[i] = newNode(hash, key, value, null);
	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 {
            /**
            *循环遍历阶段，e = p.next必须执行，导致e被赋予了p的第一个节点的地址，如果为空，则直接将加				
            *入的元素导入，如果不是空，说明后面还有节点，判断后面节点的hash值或者键是否一致，是则直接跳			
            *出循环，重复元素，因而不导入，否，则将p初始化为下一个节点，然后继续循环遍历，直到找到合适结果
            */
	        for (int binCount = 0; ; ++binCount) {
	            if ((e = p.next) == null) {
	                p.next = newNode(hash, key, value, null);
	                if (binCount >= TREEIFY_THRESHOLD - 1) 
	                    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;
}
/**
*扩容方法resize()
*/
final Node<K,V>[] resize() {
	Node<K,V>[] oldTab = table;
	int oldCap = (oldTab == null) ? 0 : oldTab.length;
	int oldThr = threshold;
	int newCap, newThr = 0;
	if (oldCap > 0) {
	    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
	}
	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) {
	    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;
	            if (e.next == null)			//该链表只有一个元素（只有一个头节点）
	                newTab[e.hash & (newCap - 1)] = e;	//放入扩容后的新桶位置，为头节点位置
	            else if (e instanceof TreeNode)
	                ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
	            else { // 如果该节点后面还有很多元素，且不是树结构
	                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) {	//重新与newCap - 1计算位置其实就是原位置 + oldCap
	                    hiTail.next = null;
	                    newTab[j + oldCap] = hiHead;
	                }
	            }
	        }
	    }
	}
	return newTab;