注释很详细，一定能看懂
给大家一个建议，可以通过对源码打断点debug进行学习，还有源码中的注释真的很重要
本文主要讲述HashMap的get、put、resize方法、HashMap与HashTable的区别、HashMap1.7和1.8的区别。
首先看一下HashMap的基础属性，接着学习一下hashMap的get、put以及resize方法。
基础属性:
// 默认的初始化容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// hashMap的table数组的最大容量，但这容量不是一个map可以存的最大元素数量，
//理论上最大值为size()方法的返回值类型的最大值，也就是int类型的最大值
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认负载因子，存储的元素大于数组长度*负载因子时会进行扩容，比如map初始化数组长度为16，
//默认负载因子为0.75，在16*0.75=12，在map.size()大于12时进行扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 链表节点转换红黑树节点的阈值, 9个节点转
static final int TREEIFY_THRESHOLD = 8;
// 红黑树转链表节点的阈值，6个节点转
static final int UNTREEIFY_THRESHOLD = 6;
// 转红黑树的最小table长度
static final int MIN_TREEIFY_CAPACITY = 64;
// 存储键值对的数据结构
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;
}
// ...
}
// 红黑树数据结构
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);
}
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
//...这里再多说一点，至于负载因子为什么取0.75？在源码中作者也给出了解释：在理想情况下，使用随机哈希吗，节点出现的频率在tab中遵循泊松分布，同时给出了数组中元素的个数和概率的对照表。从上表可以看出当数组中一个位置到达8个元素的时候，概率已经变得非常小，也就是说用0.75作为负载因子，每个碰撞位置的链表长度超过8个是几乎不可能的。HashMap负载因子为0.75是空间和时间成本的一种折中。
定位Node<K,V>[] table的索引位置
不管是map的增删改查键值对，定位到数组索引是第一步，而定位索引必须计算j键值对中key的hash值，这样做就是为了让存储到map中元素都能更加均匀，最好是每个位置只有一个，或者没有元素，尽量不发生冲突，如果是这种情况，那么在得出数组的索引时，就可以知道这个元素就是要查找的元素，不用再遍历链表或者红黑树，大大提高了HashMap的效率，所以hash算法的好坏直接影响到HashMap的性能。
// 计算key的hash值
static final int hash(Object key) {
int h;
// 先计算key对象的hashCode，再与hashCode的高16位进行异或的位运算
//从这里也可以看出可以插入键为null的值，但是只能插入一个
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
// 将(tab.length - 1) 与 hash值进行&运算，得到tab数组的下标，也就是散列到这个位置的所有元素的头索引
// 这两行代码出现在一些方法中，并没有进行封装
int n = tab.length;
int index = (n - 1) & hash;
- 计算key对象的hashCode。
- 将hashCode与hashCode的最高16位进行异或运算，重新计算hash值。
- 用table数组长度-1与运算hash值，计算得出键值对在数组中的下标。
方法分析：
对于任意计算出的hash值，完全可以采取简单的模运算，也就是直接用hash值直接对table的长度取模运算，这样一来可以直接达到散列的效果，但是jdk团队并没有这样实现，在jdk1.7里没有采用这种方法。都是按位与运算得到索引值。在Java集合：HashMap详解（JDK 1.8）（写的很好）文章中这部分有详细说明，但是我对于x mod 2^n = x & (2^n - 1)这个公式没有理解，不过采用位运算肯定比模运算效率要高，这也是为什么采用位运算的原因。
而且在jdk1.8中相比1.7，增加了将hashCode和hashCode高16位进行异或运算的步骤，主要是为了在table的length较小的时候，让高位也参与运算，并且不会有太大的开销，源码中解释是为了在table较小的时候，将hashCode的高位影响向下传播。
put方法
public V put(K key, V value) {
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;
// 当table为null或者length为0时，通过代码resize方法进行table数组的初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 通过key的hash值计算索引并判断索引位置第一个元素是否为空
// 将索引位置的头节点赋值给p，就是table[i]这个位置的元素不管是不是null，都赋值给p
if ((p = tab[i = (n - 1) & hash]) == null)
// 若为空，则新建节点，将键值对增加到table中
tab[i] = newNode(hash, key, value, null);
// 如果计算出索引，判断出索引值的第一个节点不为空，已经有元素存储在这个位置
else {
Node<K,V> e; K k;
// 判断传入的hash值和这个位置存储元素的hash值是否相等
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//如果相等，将已存在的这个元素赋值给e
// 判断p节点是否为TreeNode, 如果是则调用红黑树的putTreeVal方法插入节点
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 走到这里就已经说明这个p节点属于链表节点
else {
for (int binCount = 0; ; ++binCount) {//binCount用于统计节点数
// 如果p.next为null，说明当前table数组这个位置只有p一个节点元素
if ((e = p.next) == null) {
// 在p节点后新建节点，将新元素插入到链表尾部
p.next = newNode(hash, key, value, null);
// 计算链表节点数是否大于8，如果大于转为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 如果新元素的hash值与e节点相等，那么跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;//将p指向下一个e
}
}
// 如果e不为null，说明新插入的key已经存在，将该节点的value覆盖，返回原来的value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 插入节点后超过阈值则进行扩容，例如map初始化时，threshold=12，在插入13个元素才会进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}- 既然是向map中存入值，那么首先判断table数组是否为null，如果为null，调用resize()方法初始化数组length为n =16。
- 通过计算p = tab[i = (n - 1) & hash，散列到table的i位置，如果这个位置p为null，那么直接采用newNode(hash, key, value, null)方法构造新节点将key,value存入新节点。
- 如果i位置所对应的p节点不为null，判断已存在p节点hash值是否等于key所对应的hash值等等，其实就是判断p节点所存储的值是否等于现在需要存入的键值对，如果相等直接替换。
- 如果不相等，判断p节点是否属于TreeNode，如果属于，表明属于红黑树结构，调用putTreeVal(this, tab, hash, key, value)插入新元素到红黑树中。
- 如果不属于TreeNode，那么肯定属于链表结构，采用for循环遍历链表，如果碰到key相等的节点，进行替换，如果没有，插入到链表尾部，在遍历的过程中会判断链表长度是否为8，如果大于8，调用treeifyBin(tab, hash)将链表转换为红黑树。
- 最后判断e节点是否为null，如果为null，表明没有替换任何键值对，插入成功，如果不为null，返回替换的旧值。
这里再说明一个问题，如果是插入key是null，那么插入的位置为table[0],如果是继续插入的元素发生哈希冲突时，散列到table[0]位置，那么继续插入到null元素后面，其实不是null元素，因为这里插入的元素已经封装为node节点，所以不存在说node.next空指针异常这种情况。
resize方法：
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
// 判断老表是否为null，如果为空，oldCap赋值为0，不为空，赋值为老表大小
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// 判断老表容量是否大于0
if (oldCap > 0) {
// 判断老表容量大于表的最大容量，也就是2的30次方
if (oldCap >= MAXIMUM_CAPACITY) {
// 设置阈值为Integer.MAX_VALUE
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 否则将新容量赋值为老容量*2，如果新容量<最大容量并且老容量>=16, 则将新阈值设置为原来的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // 老表的容量为0, 老表的阈值大于0, 是因为初始容量被放入阈值
newCap = oldThr;
else { // 老表的容量为0, 老表的阈值为0, 则为空表，设置默认容量和阈值
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;threshold
@SuppressWarnings({"rawtypes","unchecked"})
// 初始化新表和大小，将新表赋值给table
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 老表若不为null，那么遍历节点将节点赋值给新表
if (oldTab != null) {
// 遍历老表的每个位置
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
// 若索引值为j的节点不为空，将它赋值给e
if ((e = oldTab[j]) != null) {
// 将老表的节点设置为空, 以便垃圾收集器回收空间
oldTab[j] = null;
// 如果e.next为空，那么说明这个位置只有当前一个节点
if (e.next == null)
// 通过hash值计算新的索引值，直接将元素放到索引值位置
newTab[e.hash & (newCap - 1)] = e;
// 如果是TreeNode调用TreeNode的方法进行处理
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 定义与老表存储位置相等的链表的头结点和尾节点
Node<K,V> loHead = null, loTail = null;
// 定义与老表存储位置不相等的链表的头结点和尾节点，新表位置为：老表位置+oldCap
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
// 如果e的hash值与老表元素与运算为0，扩容后位置与老表位置一样
if ((e.hash & oldCap) == 0) {
if (loTail == null)//如果为loTail为null，说明该节点为第一个节点
loHead = e;//将e赋值为第一个节点
else
loTail.next = e;//否则将节点添加到loTail后面
loTail = e;
}
// 如果如果e的hash值与老表元素与运算不等于0，为1，扩容后位置与老表位置+oldCap
else {
if (hiTail == null)//如果为hiTail为null，说明该节点为第一个节点
hiHead = e;//将e赋值为第一个节点
else
hiTail.next = e;//否则将节点添加到hiTail后面
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;//将最后一个节点的next是指为null
newTab[j] = loHead;//最重要的一步，将与原表位置一样的头结点赋值给newTab[j]
}
if (hiTail != null) {
hiTail.next = null;//将最后一个节点的next是指为null
newTab[j + oldCap] = hiHead;//同上，将与位置发生变化的头结点赋值给newTab[j + joldCap]
}
}
}
}
}
// 返回新表
return newTab;
}这里补充两个问题
- 扩容后，节点重hash为什么只可能分布在原索引位置与原索引+oldCap位置？
这个问题可以详细参考Java集合：HashMap详解（JDK 1.8），其实核心就是重新计算hash值的方法：e.hash & (newCap - 1)，由于每次扩容都是乘以2，所以计算(e.hash & oldCap) 出来只会存在0和1这两种结果。
- jdk1.7,HashMap在并发使用时可能发生死循环，导致cpu100%，但是1.8不会？
在上述代码分析中可以看出jdk1.8在resize的时候采用的方式是后插法，而1.7采用的方式是头插法，正是这个原因导致1.7的hashMap在并发使用时会产生链表的的相互引用，形成一个环。具体可以看这两篇文章，写的很好。疫苗：JAVA HASHMAP的死循环，老生常谈，HashMap的死循环，HashMap自身就是不安全的，所以在多线程情况下建议使用ConcurrentHashMap。当然很多人说是在put方法的时候形成环路，造成死循环也是没有问题的，因为在大量put的时候肯定会进行resize。
get方法：
public V get(Object key) {
Node<K,V> e;
// 调用getNode(hash(key), key)方法，如果找到key所对应的value就返回，否则返回null
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 如果table数组不为null，而且长度大于0，而且根据key的hash值计算出来在table中的位置也不为null
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 检查table数组该位置的元素是否是key所对应要查找的值，如果是就返回
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 如果不是继续检查下一个节点
if ((e = first.next) != null) {
// 这个节点是否属于红黑树，如果调用红黑树的getTreeNode(hash, key)查找结果
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// 采用do while循环遍历链表查找key所对应的节点
do {
// 找到直接返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
// 如果没有找到就返回null
return null;
}- 调用hash(key)方法计算key的hash值。
- 判断table数组是否为null，使用first = tab[(n - 1) & hash]定位hash值所对应位置是否为null，如果为null直接返回。
- 在不为null的情况下判断table的first位置是否为TreeNode，如果是说明为红黑树结构，调用getTreeNode(hash, key)查询结果。
- 如果不是，说明是链表结构，采用do while循环来逐个遍历链表查询结果，如果不存在，返回null。
HashMap和Hashtable的区别：
- HashMap线程非安全，HashTable线程安全。
- HashMap允许<key,value>都可以为空，HashTable不允许。
- HashMap的默认初始容量为16，Hashtable为11。
- HashMap的扩容为原来的2倍，Hashtable的扩容为原来的2倍加1。
- HashMap的hash值重新计算过，Hashtable直接使用hashCode。
- HashMap去掉了Hashtable中的contains方法。
- HashMap继承自AbstractMap类，Hashtable继承自Dictionary类。
- 可以通过Map m = Collections.synchronizeMap(hashMap)使HashMap实现同步，但是在多线程情况下还是建议使用ConcurrentHashMap
HashMap1.7和1.8的区别
可以直接看这篇文章，很详细美团面试题：Hashmap的结构，1.7和1.8有哪些区别，史上最深入的分析，我摘抄出来主要点写在下面：
- JDK1.7用的是头插法，而JDK1.8及之后使用的都是尾插法
- 扩容后数据存储位置的计算方式也不一样：在JDK1.7的时候是直接用hash值和扩容的大小-1进行&运算，计算出来是哪个位置就是哪个位置，1.8在1.7计算的基础上增加了判断hash值和扩容的大小进行&的结果，如果为0，元素保持和老表位置一直，如果为1，新表位置=老表位置+老表容量
- jdk1.7，采用数组+链表，jdk1.8采用数组+链表+红黑树，在链表元素个数大于8时，链表结构转换为红黑树（如果此时table长度小于64，那么不会转换为红黑树，只是将table数组进行扩容），在删除元素后，小于6时，红黑树转换为链表结构。自动扩容把链表转成红黑树的数据结构来把时间复杂度从O（n）变成O（logN）提高了效率。
291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
