JDK1.7版本
概述
HashMap是数组+链表的方式存放元素，根据元素的hash code算出数组下标，数组下标相同的元素作为链表存放，链表是单向链表（而不是双向链表）
我下面看的源码是1.7版本，不同版本的代码是不一样的,最下面有1.8逻辑
内存简图
底层的数组是table，size是有多少个元素
每个节点都是Entry类型，包含key,value和next指针（所以是单向链表，找不到上个元素，只能找下一个元素）以及计算出来的hash值
初始化
我这个版本直接写成16，也有的版本是1<<4 （左移4位，值也是16）
loadFactor译为装载因子，装载因子用来衡量HashMap的拥挤程度。loadFactor的默认值为0.75f。当HashMap里面容纳的元素已经达到HashMap容量的75%时，表示HashMap太挤了，需要扩容，在HashMap的构造器中可以定制loadFactor。
有个默认的capacity（数组大小），如果小于初始化容量initialCapacity,就乘以2(找到2的倍数，大于等于initialCapacity的值）
table数组给了个空的数组
这个变量用于控制：数组到达多大后要扩容
init函数是空的，继承HashMap的类可以自行实现
插入元素
- 专门处理key是null的情况（如果key是null此处已经结束流程）
- 根据key计算hash值
- 根据hash和数组长度计算出数组索引下表
- 根据数组下标找到元素，查找链表，如果有一样的元素（判断一不一样，先判断地址是否相同，但如果地址一样肯定是一样的对象，如果地址不一样，equals一样，也认为是一样的元素），替换元素，返回
- 操作计数+1
- 添加元素
处理key等于null的逻辑
- 如果key是null，存放到数组的第一个元素
- 根据链表找key是否有等于null的，如果有直接替换
- 如果没有key等于null的元素新增元素
hash的计算
- 如果useAltHashing值为true,用字符串的hash进行替换，减少hash冲突的概率
- 获取key的hash code，然后跟h（默认为0）做异或（相同为0，不同为1）其实就是没有任何改变,h的值经过计算后还是key的hash code
- 最下面那两行，目的是在散列计算中减少碰撞的概率，但为啥那么写，我也没看懂
通过hash计算下标
h是hash值，length是数组长度，用与的方式，将h比length高位的bit位都变成0，然后与length相同的bit位做与运算，会根据h的地位计算出小于等于length-1的一个值（这个值与h的低位有关），达到了唯一的一个值可以找到唯一的一个下标的目的。其实这地方可以做除法取模运算（更易于理解，但速度没有位运算快）
新增元素
先判断是否需要扩容（详细内容见下面）
调用createEntry，这个函数是关键：
- 找到原有的元素e，
- 新增加一个元素Entry，并将e放到Entry的next指针中，
- 并将新的元素Entry替换到数组的位置中
- size自加
扩容逻辑
在addEntry函数中，会有扩容逻辑：
- 先判断元素个数是否超过阈值（数组长度*0.75）并且新增的这个元素的hashcode计算的下标已经有值了
- resize是扩容，目的是增加数组长度，稀释链表（原本hash code不一样计算出来的index一样，扩容后可能计算出来的index可能不一样，原本一个链表可能会变成2个链表，提升查询效率）
计算出扩容后的数据，申请个新的数组，transfer对老的数组的内容挪移到新的数组中，并将新的数组赋给table和重新计算阈值，transfer是关键
rehash代表是否重新计算hash值，忽略
遍历数组，对于每个元素，有：
- 老列表的元素e的next先缓存到局部变量，下面要用
- 重新计算hash
- 根据新数组长度，和hash，计算下标，注意，原本数组长度是16，下标可能是1，新的数组长度扩容到32，下标可能就变成17了。h & (length-1) 对于length不同，与的结果也可能不同
- 新的元素（计算出来的下标）给e的next，再将e赋给数组（注意，上述操作都是引用复制，浅拷贝，不是新生成了元素），这是头插法，多线程会出现死循环，在1.8后不用头插法，下面有1.8后续版本的resize函数中解析
头插法的BUG
1、数据插入原理
在分析原因之前，我先带大家了解一下JDK1.7中HashMap插入数据的原理，来看动画演示：
由于JDK 1.7中HashMap的底层存储结构采用的是数组 加 链表的方式。
而HashMap在数据插入时又采用的是头插法，也就是说新插入的数据会从链表的头节点进行插入。
因此，HashMap正常情况下的扩容就是是这样一个过程。我们来看，旧HashMap的节点会依次转移到新的HashMap中，旧HashMap转移链表元素的顺序是A、B、C，而新HashMap使用的是头插法插入，所以，扩容完成后最终在新HashMap中链表元素的顺序是C、B、A。
2、导致死循环的原因
接下来，我通过动画演示的方式，带大家彻底理解造成HashMap死循环的原因。我们按以下三个步骤来还原并发场景下HashMap扩容导致的死循环问题：
第一步：线程启动，有线程T1和线程T2都准备对HashMap进行扩容操作， 此时T1和T2指向的都是链表的头节点A，而T1和T2的下一个节点分别是T1.next和T2.next，它们都指向B节点。
第二步：开始扩容，这时候，假设线程T2的时间片用完，进入了休眠状态，而线程T1开始执行扩容操作，一直到线程T1扩容完成后，线程T2才被唤醒。
T1完成扩容之后的场景就变成动画所示的这样
因为HashMap扩容采用的是头插法，线程T1执行之后，链表中的节点顺序发生了改变。但线程T2对于发生的一切还是不可知的，所以它指向的节点引用依然没变。如图所示，T2指向的是A节点，T2.next指向的是B节点。
当线程T1执行完成之后，线程T2恢复执行时，死循环就发生了。
因为T1执行完扩容之后，B节点的下一个节点是A，而T2线程指向的首节点是A，第二个节点是B，这个顺序刚好和T1扩容之前的节点顺序是相反的。T1执行完之后的顺序是B到A，而T2的顺序是A到B，这样A节点和B节点就形成了死循环。
在头插法 加 链表 加 多线程并发 加 扩容这几个情形累加到一起就会形成死循环 ,多线程环境下建议采用ConcurrentHashMap替代
获取元素
根据key获取value
如果key等于null，在getForyNullKey函数中，在下标为0中找链表
如果key不等于null,在getEntry函数中，计算出来hash值，再根据hash计算下标，找到数组元素，遍历数组，满足：
- hash值必须一样（有可能hash值不一样但下标一样的，所以这地方要判断）
- key的地址一样（这个判断速度最快，但有可能是两个对象，地址不一样，但内容一样，比如两个string的张三）或者equals一样
对于key等于null的处理，找数组下标为0的元素，遍历链表
删除元素
主要的处理方法，
- 根据key算出hash再算出下标，找到数组下标元素，如果key为null，找下标为0的元素，插入的时候就往这个下标中插入的
- 下标元素（链表第一个元素）为pre元素，然后循环找next，如果e不是目标元素，e给pre，e的next给e，向后遍历查找链表，一直到e为空（最后一个元素的next为空）
- 如果找到了元素，pre等于e，说明目标元素是链表的第一个值，next赋给头结点（数组下标元素）。如果pre不等于e，把e的next给pre的next，e这个元素就从链表中删除了
recordRemoval是空实现，给子类用的
快速失败
modCount 操作修改次数，用于快速感知到iterator中内容是否经过修改
以下代码会报错
public class Main {
public static void main(String[] args) {
// write your code here
HashMap<String, String> map = new HashMap<>();
map.put("key1", "value1");
map.put("key2", "value2");
map.put("key3", "value3");
Iterator<String> itr = map.keySet().iterator();
while (itr.hasNext()) {
String key = itr.next();
if (key.equals("key2")) {
map.remove(key);
}
}
}
}
因为在keySet()中，会返回newKeyIterator，父类的初始化HashIterator，可以看到将modCount的值给了expectedModCount，当使用map做remove的时候，modCount++，但expectedModCount不变，所以在String key = itr.next();这行代码中，判断modCount与expectedModCount不一致，代表在循环过程中有人改了map，快速失败抛出异常
iterator返回的类的初始化
在map的值修改后，这地方报错
代码修改为：
这一行改成iterator的remove，在内部会有修改 expectedModCount，就不会报错了，在类HashIterator的remove函数中有以下代码，底层还是调用hashmap的remove
JDK16逻辑
1.7版本中，HashMap采用位桶+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8以后的版本中，HashMap采用位桶+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树**，这样大大减少了查找时间。
概述
数组的变量，数组元素改成了Node（继承于老版本的Entry，也是有hash和next的链表模式）
单个节点逻辑
红黑树节点
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
//父节点
TreeNode<K,V> parent; // red-black tree links
//左子树
TreeNode<K,V> left;
//右子树
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
//颜色属性
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
/**
* Returns root of tree containing this node.
* 返回当前节点的根节点
*/
final TreeNode<K,V> root() {
//从this开始找，父节点给p，如果p为null返回r
//不为null将父节点p给r，再找它的父节点（循环往上找）
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
}获取元素
/**
* Returns the value to which the specified key is mapped,
* or {@code null} if this map contains no mapping for the key.
*
* <p>More formally, if this map contains a mapping from a key
* {@code k} to a value {@code v} such that {@code (key==null ? k==null :
* key.equals(k))}, then this method returns {@code v}; otherwise
* it returns {@code null}. (There can be at most one such mapping.)
*
* <p>A return value of {@code null} does not <i>necessarily</i>
* indicate that the map contains no mapping for the key; it's also
* possible that the map explicitly maps the key to {@code null}.
* The {@link #containsKey containsKey} operation may be used to
* distinguish these two cases.
*
* @see #put(Object, Object)
*/
public V get(Object key) {
Node<K,V> e;
//主要处理逻辑是getNode函数
return (e = getNode(key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods.
*
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n, hash; K k;
//根据KEY算出HASH算出数组table的下标元素first
//如果链表第一个元素first是要查的元素直接返回
//如果first是红黑树节点，用红黑树查找方法。否则用while遍历next
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & (hash = hash(key))]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
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;
}新增元素
/**
* Associates the specified value with the specified key in this map.
* If the map previously contained a mapping for the key, the old
* value is replaced.
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
* @return the previous value associated with {@code key}, or
* {@code null} if there was no mapping for {@code key}.
* (A {@code null} return can also indicate that the map
* previously associated {@code null} with {@code key}.)
*/
public V put(K key, V 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;
//数组如果为空，扩容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//KEY算出来的下标元素如果为空（不需要链表操作），直接新增一个node放进去
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//已经有HASH一样的元素，进入链表操作
Node<K,V> e; K k;
//第一个元素的KEY与本次操作的KEY一样，找到目标元素
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 {
//如果目标HASH和数组元素HASH一样但KEY不一样会进入这里
for (int binCount = 0; ; ++binCount) {
//找到了链表尾部，新插入一个节点
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//treeifyBin首先判断当前hashMap的长度，如果不足64，只进行
//resize，扩容table，如果达到64，那么将冲突的存储结构为红黑树
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;
//大小超过阈值，扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}resize扩容逻辑
注意，在1.7版本中，扩容做数据挪移使用的头插法，在多线程中会有死循环的BUG，在1.8后续版本不使用头插法，从头结点遍历next生成新的链表
/**
* 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() {
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;
}
/*把新表的长度设置为旧表长度的两倍，newCap=2*oldCap*/
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
/*如果旧表的长度的是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) {
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;
//说明这个node没有链表直接放在新表的e.hash & (newCap - 1)位置
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
/*如果e后边有链表,到这里表示e后面带着个单链表，需要遍历单链表，将每个结点重*/
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;
//新表是旧表的两倍容量，实例上就把单链表拆分为两队，
//e.hash&oldCap为偶数一队，e.hash&oldCap为奇数一对
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) {//lo队不为null，放在新表原位置
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {//hi队不为null，放在新表j+oldCap位置
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}JDK1.8使用红黑树的改进
在Java jdk8中对HashMap的源码进行了优化，在jdk7中，HashMap处理"碰撞"的时候，都是采用链表来进行存储，当碰撞的节点很多时，查询时间是O(n)。
在jdk8中，HashMap处理"碰撞"增加了红黑树这种数据结构，当碰撞节点较少时，采用链表存储，当较大时(>8个)，采用红黑树(特点是查询时间是O(logn)）存储（有一个阀值控制，大于阀值(8个)，将链表存储转换成红黑树存储）
6714
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
