本文适当参考了以下几篇博客：
感谢！！
以下内容是
加上自己翻看源码理解整理而得，有点乱，以后有空再整理下：
一：关于HashMap的几个总结
1.HashMap的key和value都允许为null
2.HashMap不保证映射的顺序
3.HashMap不是同步的
二：我们看下HashMap的类关系
我们可以看到：
public class HashMap<K,V> extends AbstractMap<K,V>1.继承于抽象类AbstractMap
implements Map<K,V>, Cloneable, Serializable
2.实现Map接口、Cloneable和Serializable接口
三：主要的类成员属性
/**
* 默认的初始化容量，1 << 4 左移四位相当于 1 * 2 ^ 4 值为16
* 必须是2的n次幂
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
*
* 最大容量为1<<30，即2的30次方
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认的加载因子
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 将链表转为红黑树的临界值
*
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 恢复成链式结构的桶大小临界值
* 小于TREEIFY_THRESHOLD，临界值最大为6
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 桶可能被转化为树形结构的最小容量。当哈希表的大小超过这个阈值，才会把链式结构转化成树型结构，否则仅采取扩容来尝试减少冲突。
* 应该至少4*TREEIFY_THRESHOLD来避免扩容和树形结构化之间的冲突。
*/
static final int MIN_TREEIFY_CAPACITY = 64;
分析：上面提高了两个概念,
初始容量和加载因子
这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认负载因子为0.75，一般情况下我们是无需修改的。
这里我们有必要先认识下HashMap的数据结构，以便更好的分析源码
在分析HashMap源码之前，有必要了解HashMap的数据结构，否则很难理解下面的内容。
ps:图片来自网上，感觉这个图画的不错。
从上图中可以很清楚的看到，HashMap的数据结构是数组+链表+红黑树（红黑树since JDK1.8）。我们常把数组中的每一个节点称为一个桶。当向桶中添加一个键值对时，首先计算键值对中key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这种现象称为碰撞，这时按照尾插法(jdk1.7及以前为头插法)的方式添加key-value到同一hash值的元素的后面，链表就这样形成了。当链表长度超过8(TREEIFY_THRESHOLD)时，链表就转换为红黑树。
这里的核心其实就是节点数组
Node<K,V>[]
然后每个节点Node对象如下：
**
* 静态内部类，Node节点
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
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; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
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;
}
}
四：构造函数
1.无参构造方法
/**分析： 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。注意初始容量需要第一次使用的时候，才会进行初始化
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
2.HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap
/**分析：传入指定的初始容量initialCapacity，同时传入默认加载因子，调用this方法
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and the default load factor (0.75).
*
* @param initialCapacity the initial capacity.
* @throws IllegalArgumentException if the initial capacity is negative.
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and load factor.
*
* @param initialCapacity the initial capacity
* @param loadFactor the load factor
* @throws IllegalArgumentException if the initial capacity is negative
* or the load factor is nonpositive
*/
public HashMap(int initialCapacity, float loadFactor) {
//如果初始容量小于0，报错
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//大于最大容量，直接等于最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//加载因子小于等于0或则加载因子不是数字抛错（isNaN 实际上就是 Not a Number的简称。0.0f/0.0f的值就是NaN，从数学角度说，0/0就是一种未确定）
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//阈值 等于 initialCapacity最小的二次幂数值。
this.threshold = tableSizeFor(initialCapacity);
}
分析：校验初始容量和加载因子，最后threshold阈值等于调用tableSizeFor()方法返回的值，tableSizeFor()返回的是大于等于初始化容量的最小二次幂数值。
继续看下tableSizeFor()方法
/**分析：该方法返回大于等于cap的最小的二次幂数值
* Returns a power of two size for the given target capacity.
* 返回大于等于cap的最小的二次幂数值。
*/
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;
}
类似如下：
来看下ArrayDeque是怎么做的吧：
private void allocateElements(int numElements) {
int initialCapacity = MIN_INITIAL_CAPACITY;
// Find the best power of two to hold elements.
// Tests "<=" because arrays aren't kept full.
if (numElements >= initialCapacity) {
initialCapacity = numElements;
initialCapacity |= (initialCapacity >>> 1);
initialCapacity |= (initialCapacity >>> 2);
initialCapacity |= (initialCapacity >>> 4);
initialCapacity |= (initialCapacity >>> 8);
initialCapacity |= (initialCapacity >>> 16);
initialCapacity++;
if (initialCapacity < 0) // Too many elements, must back off
initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
}
elements = new Object[initialCapacity];
}
看到这段迷之代码了吗？在HashMap中也有一段类似的实现。但要读懂它，我们需要先掌握以下几个概念：
在java中，int的长度是32位，有符号int可以表示的值范围是 (-2)31 到 231-1，其中最高位是符号位，0表示正数，1表示负数。
>>>：无符号右移，忽略符号位，空位都以0补齐。|：位或运算，按位进行或操作，逢1为1。
我们知道，计算机存储任何数据都是采用二进制形式，所以一个int值为80的数在内存中可能是这样的：
0000 0000 0000 0000 0000 0000 0101 0000
比80大的最近的2次幂是128，其值是这样的：
0000 0000 0000 0000 0000 0000 1000 0000
我们多找几组数据就可以发现规律：
每个2的次幂用二进制表示时，只有一位为 1，其余位均为 0（不包含符合位）
要找到比一个数大的2的次幂（在正数范围内），只需要将其最高位左移一位（从左往右第一个 1 出现的位置），其余位置 0 即可。
但从实践上讲，没有可行的方法能够进行以上操作，即使通过&操作符可以将某一位置 0 或置 1，也无法确认最高位出现的位置，也就是基于最高位进行操作不可行。
但还有一个很整齐的数字可以被我们利用，那就是 2n-1，我们看下128-1=127的表示形式：
0000 0000 0000 0000 0000 0000 0111 1111
把它和80对比一下：
0000 0000 0000 0000 0000 0000 0101 0000 //80
0000 0000 0000 0000 0000 0000 0111 1111 //127
可以发现，我们只要把80从最高位起每一位全置为1，就可以得到离它最近且比它大的 2n-1，最后再执行一次+1操作即可。具体操作步骤为（为了演示，这里使用了很大的数字）：
原值：
0011 0000 0000 0000 0000 0000 0000 0010
- 无符号右移1位
0001 1000 0000 0000 0000 0000 0000 0001
- 与原值
|操作：
0011 1000 0000 0000 0000 0000 0000 0011
可以看到最高2位都是1了，也仅能保证前两位为1，这时就可以直接移动两位
- 无符号右移2位
0000 1110 0000 0000 0000 0000 0000 0000
- 与原值
|操作：
0011 1110 0000 0000 0000 0000 0000 0011
此时就可以保证前4位为1了，下一步移动4位
- 无符号右移4位
0000 0011 1110 0000 0000 0000 0000 0000
- 与原值
|操作：
0011 1111 1110 0000 0000 0000 0000 0011
此时就可以保证前8位为1了，下一步移动8位
- 无符号右移8位
0000 0000 0011 1111 1110 0000 0000 0000
- 与原值
|操作：
0011 1111 1111 1111 1110 0000 0000 0011
此时前16位都是1，只需要再移位操作一次，即可把32位都置为1了。
- 无符号右移16位
0000 0000 0000 0000 0011 1111 1111 1111
- 与原值
|操作：
0011 1111 1111 1111 1111 1111 1111 1111
- 进行+1操作：
0100 0000 0000 0000 0000 0000 0000 0000
如此经过11步操作后，我们终于找到了合适的2次幂。写成代码就是：
initialCapacity |= (initialCapacity >>> 1);
initialCapacity |= (initialCapacity >>> 2);
initialCapacity |= (initialCapacity >>> 4);
initialCapacity |= (initialCapacity >>> 8);
initialCapacity |= (initialCapacity >>> 16);
initialCapacity++;
不过为了防止溢出，导致出现负值（如果把符号位置为1，就为负值了）还需要一次校验：
if (initialCapacity < 0) // Too many elements, must back off
initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
这样我们就明白了计算最小二次幂数值的原理。
3.
使用指定的初始化容量initial capacity 和加载因子load factor构造一个空HashMap
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and load factor.
*
* @param initialCapacity the initial capacity
* @param loadFactor the load factor
* @throws IllegalArgumentException if the initial capacity is negative
* or the load factor is nonpositive
*/
public HashMap(int initialCapacity, float loadFactor) {
//如果初始容量小于0，报错
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//大于最大容量，直接等于最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//加载因子小于等于0或则加载因子不是数字抛错（isNaN 实际上就是 Not a Number的简称。0.0f/0.0f的值就是NaN，从数学角度说，0/0就是一种未确定）
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//阈值 等于 initialCapacity最小的二次幂数值。
this.threshold = tableSizeFor(initialCapacity);
}
分析：同上面调用this方法。
4.构造方法传入一个map初始化
/**分析：加载因子等于默认的0.75f，然后调用putMapEntries()方法
* Constructs a new <tt>HashMap</tt> with the same mappings as the
* specified <tt>Map</tt>. The <tt>HashMap</tt> is created with
* default load factor (0.75) and an initial capacity sufficient to
* hold the mappings in the specified <tt>Map</tt>.
*
* @param m the map whose mappings are to be placed in this map
* @throws NullPointerException if the specified map is null
*/
public HashMap(Map<? extends K, ? extends V> m) {
//加载因子等于默认的0.75f
this.loadFactor = DEFAULT_LOAD_FACTOR;
//传入map调用putMapEntries方法
putMapEntries(m, false);
}
/**分析：如果传入的map长度大于0，那么进行如下逻辑判断：
* Implements Map.putAll and Map constructor
*
* @param m the map
* @param evict false when initially constructing this map, else
* true (relayed to method afterNodeInsertion).
* 判断当前传入的Map长度大于阈值threshold，则HashMap调用resize()方法先扩容
* 遍历传入的Map将值添加到HashMap里
*/
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//map长度s
int s = m.size();
if (s > 0) {
//table是一个node节点数组(Node<K,V>[] table)
if (table == null) { // pre-size
//map长度s先转为float 然后 除以 加载因子0.75f, 最后加上1.0F得到ft
float ft = ((float)s / loadFactor) + 1.0F;
//如果ft小于最大容量为1<<30则t等于ft,否则t等于最大容量为1<<30即2的30次方
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
//如果t大于阈值threshold
if (t > threshold)
//阈值等于满足大于等于t的最小的二次幂数值
threshold = tableSizeFor(t);
}
//如果map长度s大于阈值threshold,需要扩容
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);
}
}
}
1.当前节点数组为null，计算阈值大小
2.如果table不等于Null,map长度s大于阈值threshold，调用resize()扩容
3.遍历传入的map，将值添加到HashMap
到这里，我们其实知道以
构造方法传入一个map初始化方式，在调用putMapEntries时，table=null，计算完阈值后，不会调用resize()扩容，而是进行遍历然后putVal（）操作，相关容量初始化操作，我猜测应该是在putVal()方法里进行，不着急，我们往下会继续分析。
五：主要方法
1.hash(Object key) 哈希算法
在JDK1.8的实现中，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)，主要是从速度、功效、质量来考虑的。以下方法得到的int的hash值，
static final int hash(Object key) {分析：参考如下知乎评论 https://www.zhihu.com/question/20733617
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
大家都知道上面代码里的key.hashCode()函数调用的是key键值类型自带的哈希函数，返回int型散列值。
理论上散列值是一个int型，如果直接拿散列值作为下标访问HashMap主数组的话，考虑到2进制32位带符号的int表值范围从-2147483648到2147483648。前后加起来大概40亿的映射空间。只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。
但问题是一个40亿长度的数组，内存是放不下的。
你想，HashMap扩容之前的数组初始大小才
16。所以这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算（也就是HashMap的长度），
得到的余数才
能用来访问数组下标。源码中模运算是在这个
indexFor( )
函数里完成的。
bucketIndex = indexFor(hash, table.length);static int indexFor(int h, int length) { return h & (length-1);}
顺便说一下，这也正好解释了为什么HashMap的数组长度要取2的整次幂。因为这样（数组长
度-1）正好相当于一个“
低位掩码”。
“与”操作的结果就是散列值的高位全部归零，只保留低位
值，用来做数组下标访问。以初始长度16为例，16-1=15。2进制表示是
00000000 00000000 00001111。和某散列值做“与”操作如下，结果就是截取了最低的四位值。这里的某散列值就是随机的一个数如下的10100101 11000100 00100101。
但这时候问题就来了，这样就算我的散列值分布再松散，要是只取最后几位的话，碰撞也会很严
重。更要命的是如果散列本身做得不好，分布上成等差数列的漏洞，恰好使最后几个低位呈现规律
性重复，就无比蛋疼。
这时候“
扰动函数
”的价值就体现出来了，说到这里大家应该猜出来了。看下面这个图
ps:
1.调用hashCode（）得到随机的散列值1111 1111 1111 1111 1111 0000 1110 1010
2.无符号右移16位 0000 0000 0000 0000 1111 1111 1111 1111
3.h ^ (h >>> 16) 高16位与低16位异或 (ps: ^ 异或运算)
为什么做异或运算？
设想一下，如果n很小，假设为16的话，那么n-1即为15（0000 0000 0000 0000 0000 0000 0000 1111），这样的值如果跟hashCode()直接做与操作，实际上只使用了哈希值的后4位。如果当哈希值的高位变化很大，低位变化很小，这样很容易造成碰撞，所以把高低位都参与到计算中，从而解决了这个问题，而且也不会有太大的开销。
其实到此我们就得到hash值（散列值），也就是
hash(Object key)函数功能，但是我们以后如果需要根据hash值来获取HashMap值所在的下表，还需要将hash值与(HashMap长度 - 1)进行与运算（ps： &" 与"运算，两者都为1才得1,"
&"这是是什么运算？）
（n - 1）& hash
右位移16位，正好是32bit的一半，自己的高半区和低半区做异或，就是为了
混合原始哈希码的高位和低位，以此来增加大低位的随机性。而且混合后的低位掺杂了高位的部分特征，这样高位的信息也被变相保留下来。
最后我们来看一下
Peter Lawley
的一篇专栏文章 《
An introduction to optimising a hashing
strategy》里的一个实验：
他随机选取了352个字符串，在他们散列值完全没有冲突的前提下，对它们做低位掩码，取数组下标。
结果显示，当HashMap数组长度为512的时候，也就是用掩码取低9位的时候，在没有扰动函数的
情况下，发生了103次碰撞，接近30%。而在使用了扰动函数之后只有92次碰撞。碰撞减少了将近
10%。看来扰动函数确实还是有功效的。
得到这个hash值我们可以
再通过
h & (table.length -1)
来得到该对象在数据中保存的位置。
2.get(Object key) 返回指定key值的映射，如果value为null,则返回null！！
public V get(Object key) {分析：从源码中我们可以知道，get()方法先调用hash（key）得到哈希值，然后调用getNode()方法
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**分析：根据tab[(n - 1) & hash]取到桶节点，判断是否匹配，匹配则返回该节点值，否则返回null。
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*
* tab[(n - 1) & hash可以理解为桶节点，也就是数组中的节点
*/
final Node<K,V> getNode(int hash, Object key) {
//定义一些临时变量，first等于桶节点
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//如果HashMap不为null且长度大于0且桶节点不为null
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//如果桶节点hash值等于传入的哈希值和key值等于传入的key值。。。
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
//返回桶节点
return first;
//如果桶位置节点没匹配上且下一个节点不为null
if ((e = first.next) != null) {
//如果当前的桶采用红黑树，则调用红黑树的get方法去获取节点
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//如果是采用链表，则遍历链表直到匹配
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
到这里借用下别人的get方法总结：http://cmsblogs.com/?p=3959
从源码中可以看到，get(E e)可以分为三个步骤：
- 通过hash(Object key)方法计算key的哈希值hash。
- 通过getNode( int hash, Object key)方法获取node。
- 如果node为null，返回null，否则返回node.value。
hash方法又可分为三步：
- 取key的hashCode第二步
- key的hashCode高16位异或低16位
- 将第一步和第二部得到的结果进行取模运算。
getNode方法又可分为以下几个步骤：
- 如果哈希表为空，或key对应的桶为空，返回null
- 如果桶中的第一个节点就和指定参数hash和key匹配上了，返回这个节点。
- 如果桶中的第一个节点没有匹配上，而且有后续节点
- 如果当前的桶采用红黑树，则调用红黑树的get方法去获取节点
- 如果当前的桶不采用红黑树，即桶中节点结构为链式结构，遍历链表，直到key匹配
- 找到节点返回null，否则返回null。
3.resize() 扩容
final Node<K,V>[] resize() {分析： resize()会对HashMap进行扩容，并且重新计算初阈值（阈值：可以理解为当HashMap的长度达到阈值，就需要扩容），大致步骤如下：
//oldTab旧的Node节点数组
Node<K,V>[] oldTab = table;
//旧节点数组长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//旧的阈值
int oldThr = threshold;
//新的数组长度newCap(也就是容量)，新的阈值newThr
int newCap, newThr = 0;
//如果旧节点数组长度大于0
if (oldCap > 0) {
//如果旧节点数组长度大于最大容量为1<<30,则阈值等于int最大值，并直接返回旧节点数组 Node<K,V>[] oldTab
if (oldCap >= MAXIMUM_CAPACITY) {
//阈值等于int最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
//让新容量等于旧容量的两倍值，新容量小于最大容量为1<<30，并且旧容量大于等于默认的初始化容量16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//新的阈值变为旧的阈值两倍
newThr = oldThr << 1; // double threshold
}
//如果旧容量（数组长度）<=0,并且旧的阈值大于0
else if (oldThr > 0) // initial capacity was placed in threshold
//新的数组长度等于旧阈值大小
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//如果旧容量<=0,旧阈值<=0
// 那么新数组长度等于默认的初始化容量16
newCap = DEFAULT_INITIAL_CAPACITY;
//新阈值等于 0.75f * 16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的阈值等于0
if (newThr == 0) {
//ft等于 新容量 * 初始化容量16
float ft = (float)newCap * loadFactor;
//如果新容量newCap小于最大容量为1<<30并且ft小于最大容量为1<<30，那么新阈值等于ft,否则等于int最大值
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//阈值等于新的阈值newThr大小
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//new一个新的Node节点数组,长度等于新容量newCap
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//直接等于最新的节点数组
table = newTab;
//如果旧table不为空，将旧table中的元素复制到新的table
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 { // preserve order
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;
}
1.判断旧节点数组长度是否大于0，如果大于0，节点数组长度（ps:也就是HashMap容量）和阈值翻倍。
2.如果旧节点数组长度小于等于0，并且旧阈值大于0，那么新节点数组长度等于旧阈值（注意这里是HashMap容量等于阈值！）。
3.如果旧节点数组长度小于等于0且阈值小于等于0，初始化，节点数组长度为16，阈值为0.75f * 16。
4.如果旧数组长度小于等于0并且阈值大于0，那么新阈值等于重新计算后的ft值
5.旧阈值等于新阈值newThr
6.旧节点数组等于新节点数组newTab
7.如果旧节点数组有值，将元素赋值到新的节点数组newTab中
4.put(k key, V value) 添加方法，键值对形式
public V put(K key, V value) {分析：先通过key键值调用hash()函数计算哈希值，然后调用putVal()方法，传入哈希值，key, value
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//定义一些临时变量
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果HashMap为null或长度为0,则先调用resize()方法初始化HashMap
if ((tab = table) == null || (n = tab.length) == 0)
//先给HashMap进行初始化，变量n等于初始化后的长度
n = (tab = resize()).length;
//如果映射的桶节点为null则新建一个节点，令p节点等于桶节点tab[i = (n - 1) & hash]
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//映射的桶节点不为null
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 {
//桶节点没匹配上且为链表结构,遍历链表
for (int binCount = 0; ; ++binCount) {
//链表尾部,插入键值对
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;
}
//当前节点e匹配上hash和key
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//p结点等于e节点
p = e;
}
}
//如果key映射的节点e不为null
if (e != null) { // existing mapping for key
记录节点的vlaue
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
替换value
e.value = value;
//回调
afterNodeAccess(e);
//返回旧节点值
return oldValue;
}
}
//修改次数加1
++modCount;
//如果HashMap长度大于阈值
if (++size > threshold)
//则调用resize()方法扩容
resize();
//插入后回调
afterNodeInsertion(evict);
return null;
}
putVal方法可以分为下面的几个步骤（ps: 参考别人的总结 http://cmsblogs.com/?p=3959）：
- 如果哈希表为空，调用resize()创建一个哈希表。
- 如果指定参数hash在表中没有对应的桶，即为没有碰撞，直接将键值对插入到哈希表中即可。
- 如果有碰撞，遍历桶，找到key映射的节点
- 桶中的第一个节点就匹配了，将桶中的第一个节点记录起来。
- 如果桶中的第一个节点没有匹配，且桶中结构为红黑树，则调用红黑树对应的方法插入键值对。
- 如果不是红黑树，那么就肯定是链表。遍历链表，如果找到了key映射的节点，就记录这个节点，退出循环。如果没有找到，在链表尾部插入节点。插入后，如果链的长度大于TREEIFY_THRESHOLD这个临界值，则使用treeifyBin方法把链表转为红黑树。
- 如果找到了key映射的节点，且节点不为null
- 记录节点的vlaue。
- 如果参数onlyIfAbsent为false，或者oldValue为null，替换value，否则不替换。
- 返回记录下来的节点的value。
- 如果没有找到key映射的节点（2、3步中讲了，这种情况会插入到hashMap中），插入节点后size会加1，这时要检查size是否大于临界值threshold，如果大于会使用resize方法进行扩容。
5.remove(Object key) 根据key删除value
public V remove(Object key) {分析：先调用hash（key）计算哈希值，调用removeNode()移除
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**分析：参考总结步骤
* Implements Map.remove and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to match if matchValue, else ignored
* @param matchValue if true only remove if value is equal
* @param movable if false do not move other nodes while removing
* @return the node, or null if none
*/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
//临时记录的一些变量
Node<K,V>[] tab; Node<K,V> p; int n, index;
如果HashMap不为null且长度大于0且桶节点不为null
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
//如果桶节点node就是要删除的节点，记录桶节点node = p
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
//如果桶节点不是要删除的节点，且下一节点不为Null
else if ((e = p.next) != null) {
//桶节点结构是红黑树
if (p instanceof TreeNode)
//记录节点node等于调用红黑树获取的节点值
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//如果是链表，则遍历直至找到要删除的节点
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//如果得到的node不为null且(matchValue为false||node.value和参数value匹配)
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果要删除的节点为红黑树结构
if (node instanceof TreeNode)
//调用红黑色删除节点方法
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果要删除的节点就是桶节点
else if (node == p)
//桶节点的值等于桶节点下一个节点（相当于引用直接指向下一个节点）
tab[index] = node.next;
else
//如果桶内的结构为链表，使用链表删除元素的方式删除node(当前结点引用指向删除节点的下一个节点)
p.next = node.next;
//修改次数加1
++modCount;
//HashMap长度减1
--size;
//删除节点后需要的操作
afterNodeRemoval(node);
//返回节点
return node;
}
}
return null;
}
- 如果数组table为空或key映射到的桶为空，返回null。
- 如果key映射到的桶上第一个node的就是要删除的node，记录下来。
- 如果桶内不止一个node，且桶内的结构为红黑树，记录key映射到的node。
- 桶内的结构不为红黑树，那么桶内的结构就肯定为链表，遍历链表，找到key映射到的node，记录下来。
- 如果被记录下来的node不为null，删除node，size-1被删除。
- 返回被删除的node。
到此：我们就把HashMap源码简单的过了一遍。但是，其中关于红黑树的内容，目前暂时都跳过了，以后开一篇单独分析。
有疑问，扫我二维码添加微信，欢迎骚扰！
坚持做一件事，一起学习。
扫一扫
962
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
