HashMap是我们平时使用非常多的一个集合，它最大的一个好处是通过Hash算法查询效率非常高，学习这个集合主要是这几个点：1.解决Hash碰撞的思路；2.Hash算法的原理，以及背后原因；3.对底层的结构的优化。我对三个点逐一的展开讨论。
1.HashMap之底层结构
在们接触通过hash算法存储数据结构，我知道的大概有三种，一种是叫开放地址法，底层使用一个数组或者链表，开放地执法有一个公式:Hi=(H(key)+di) MOD m i=1,2,…,k(k<=m-1)，其中，m为哈希表的表长。di 是产生冲突的时候的增量序列。如果di值可能为1,2,3,…m-1，称线性探测再散列。如果di取1，则每次冲突之后，向后移动1个位置.如果di取值可能为1,-1,2,-2,4,-4,9,-9,16,-16,…k*k,-k*k(k<=m/2)，称二次探测再散列。如果di取值可能为伪随机数列，称伪随机探测再散列。
还有一种叫做拉链法，这种结构相当于数组+链表，大概的结构如下图：
而我们的HashMap采用的是拉链法（但Java对这个结构做了优化），首先数组记录的是每一个值的hash，然后通过算法计算hash对应哪一个数组index，然后往链表后面加一个值。
只针对HashMap了解一下两种结构的优缺点。对于第一种解决方案，使用第一种方案，随着数据的增加，一个数组（链表）有限，随着数据量增加需要对底层进行扩容，一旦扩容，那又需要重新对以前的数据进行重新hash，这样的带价是很大的，这样的结构负载因子loadFactor>=1。而使用第二种因为底层是一个数组链表理论上可以无限的加元素，承载能力非常强loadFactor >0。
那拉链法为什么是使用数组+链表，而不是链表+链表，数组+数组，链表+数组？这个自己思考一下为什么。哈哈，这里的每一个设计都充分考虑了两个因素：读效率写效率
2.HashMap之Hash算法
这个地方是HashMap的精髓之一（算法+结构），Hashmap是一个读写考虑以及存储效率极高的数据结构，对新加元素位置的确定，对于读和写的逻辑都离不开Hash算法实现，现在逐一的分析hash值的计算过程，这里的都是基于Java8源码。我们以首先看一下get方法的源码：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
} /**
* Implements Map.get and related methods
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != 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;
}从源码我们可以看到，取一个元素，首先计算hash值，然后通过计算的Hash值确定元素所在的桶的位子，也就是位于哪一个链表下面。看下hash值的计算的源码：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}我们可以看都获取hash值并不是直接拿对象hash值，而是经过位运算计算的，他这么做时为什么呢？为什么需要右位移16位？为什么不是其他的数字？还有一个数组大小都是2的指数，扩容也是以2的倍大小扩容的？
在回答这些问题之前先看下计算出hash值之后怎么取拿到桶的index的，看源码getNode方法可以看：first = tab[(n - 1) & hash]) ，其中n为数组的长度。前面我们已经知道n是2的整次幂，这样n-1相当于一个低位掩码，例如n=16时，n-1=15,二进制为1111，那么只保留低四位，高位全部为0。
10100101 11000100 00100101
00000000 00000000 00001111
----------------------------------
00000000 00000000 00000101 这样计算出来的值只会在区间[0,n-1]，正好可以通过这个来计算在数组的位置，但是这个时候可能有问题，这个和2的整数幂有啥关系呢？比如如果n是10的整数幂也可以啊，功能上是可以，但是这个计算出来的是不均匀的，也就是hash&10 等到值只能得到0 2 8 10这三个数，也就是别的只有使用掩码才能散列一个均匀的值。这也正好解释了为什么HashMap的数组长度要取2的整次幂。因为这样（数组长度-1）正好相当于一个“低位掩码”。“与”操作的结果就是散列值的高位全部归零，只保留低位值，用来做数组下标访问。
然后解释一下Hash值算法，我们知道一个对象的hash值是int类型的值，是一个32位进制的数字，而(key.hashCode()) ^ (h >>> 16)相当于用高16位和低16位进行异或，相当于把整个hash值变相的压缩记录在一个值里面，那么做的好处是什么？混合原始哈希码的高位和低位，以此来加大低位的随机性。这样的一个函数我们称为干扰函数，使用干扰函数可以大大降低我们的碰撞率。
3.HashMap的底层优化以及源码
我前面我们已经知道，HashMap的底层数据结构是数组加链表，在查询分两步，第一步获取数组的index这一步的时间复杂度是O(1),而链表的查询复杂度是O(n),在一种极端的情况下，如果加入的元素元素都同时命中了同一个桶，这个时候的时间复杂度是成线性关系的O(n),在Java8 中对这种结构进行了优化，当链表的个数大于大于或者等于8时，会把结构调整为一个红黑树。接下来我们通过源码来看HashMap的实现，需要比较核心的就是get以及put方法展开。在开始之前先介绍一下HashMap几个重要的属性：
1.static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;默认的MashMap的大小（这里的指的数组桶的大小）
2.static final int MAXIMUM_CAPACITY = 1 << 30;最大的允许的大小
3.static final float DEFAULT_LOAD_FACTOR = 0.75f;默认的负载因子（数组大小/元素个数），这个值经过数据统计，使得查找效率和空间总和的结果。
4.static final int TREEIFY_THRESHOLD = 8;当链表大于等于8时，链表就会转化成红黑树
5.static final int UNTREEIFY_THRESHOLD = 6;当红黑树数目小于等于6时，会退化为链表
6.static final int MIN_TREEIFY_CAPACITY = 64;在判断链表个数之后，还会判断桶的数量，大于64才会构建红黑树，否则通过扩容解决。
在看别的源码前，我么可以看下其中的一个构造方法：
/**
* Returns a power of two size for the given target capacity.
*/
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;
}该方法保证在用户指定任何值，得到hashMap容量都在2整数幂且size=Min(2^n>=cap),我们来一步步来分析代码。
int n = cap - 1;这个为什么首先-1？当我们一开始初始化的就是2^n的大小的时候，不-1得到的数字是其两倍。现在假设cap=9：
cap=9;
int n=9-1;
第一步：n=1000|100;
1000
100
--------
1100
第二步：n=1100|10
1100
10
--------
1110
第三部：n=1110|1
1110
1
--------
1111
之后最终得到是1111 十进制为15
最后在不大于最大临界值时，n+1=16;这个规律显而易见，总结就是把cap上二进制每一位置换为1，得到2^n-1的值，最后+1就是2整数幂。
接下看下put方法源码以及注释：
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)//当桶为空或者为null，分配空间，默认大小为DEFAULT_INITIAL_CAPACITY=16
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)//通过计算的hash值，得到桶元素的下标
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 {//此时是一个单项链表
for (int binCount = 0; ; ++binCount) {//统计该链表有多少节点
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);//把新加入的放入链表最后
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);//当链表节点大于8个，会转化为红黑树
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;//如果遇到hash值相等且对象相等时跳出循环，代替原来的value
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;//承接遇到hash值相等且对象相等时跳出循环逻辑
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//如果是新加入元素，+1，这个值用来防止使用迭代器对集合写入数据，会抛出异常
if (++size > threshold)//大于临界值会次分配空间
resize();
afterNodeInsertion(evict);
return null;这里又有几个地方比较核心的方法：resize()方法，treeifyBin(),以及modCount 。
先说一个简单的就是modCount ，这个参数的的思路不仅仅限于HashMap适用于其他的集合类。
abstract class HashIterator {
Node<K,V> next; // next entry to return
Node<K,V> current; // current entry
int expectedModCount; // for fast-fail
int index; // current slot
HashIterator() {
expectedModCount = modCount;
Node<K,V>[] t = table;
current = next = null;
index = 0;
if (t != null && size > 0) { // advance to first entry
do {} while (index < t.length && (next = t[index++]) == null);
}
}
public final boolean hasNext() {
return next != null;
}
final Node<K,V> nextNode() {
Node<K,V>[] t;
Node<K,V> e = next;
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
if ((next = (current = e).next) == null && (t = table) != null) {
do {} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
public final void remove() {
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
removeNode(hash(key), key, null, false, false);
expectedModCount = modCount;
}
}这个HashMap迭代器的实现，在对象构造时，就把expectedModCountexpectedModCount = modCount;赋值了以后nextNode方法都会校验一下map元素有没有改变，改变了就会抛出ConcurrentModificationException异常，remove也会判断，改变的数目，同时会同步数据。总结：modCount参数是用来防止使用迭代器操作集合时，防止迭代器以外的方法改变数据而导致迭代器数据不一致。它的意思表示集合的更改次数
接下来看下链表树形化的源码：
/**
* Replaces all linked nodes in bin at index for given hash unless
* table is too small, in which case resizes instead.
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {//
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)//当桶的数目比较少时，通过扩容解决效率问题
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);//把单向链表元素替换为红黑树元素
if (tl == null)
hd = p;
else {//红黑树元素同时也是一个双向链表的元素，具有前后元素的引用
p.prev = tl;//保存了单向链表的顺序
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);//链表树形化
}
}
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
for (TreeNode<K,V> x = this, next; x != null; x = next) {//按照链表的顺序，逐个构建红黑树
next = (TreeNode<K,V>)x.next;
x.left = x.right = null;
if (root == null) {//第一次遍历链表头作为红黑树的根，完成第一次遍历
x.parent = null;
x.red = false;
root = x;
}
else {//此时已经是一个有根的树
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K,V> p = root;;) {//从树的根节点开始，逐个比较
int dir, ph;
K pk = p.key;
if ((ph = p.hash) > h)//dir -1时代表加入的元素hash值小于当前节点；1代表加入的元素大于当前节点，0时相等
dir = -1;
else if (ph < h)
dir = 1;
else if ((kc == null &&//备注1
(kc = comparableClassFor(k)) == null) ||//当没有实现Comparable接口返回null
(dir = compareComparables(kc, k, pk)) == 0)//当为同一个类型则调用compareTo方法
dir = tieBreakOrder(k, pk);//比较类名字，原生hash值
TreeNode<K,V> xp = p;//保存当前比较的节点引用
if ((p = (dir <= 0) ? p.left : p.right) == null) {//-1|0 时，比较的节点向左子树移动，反之，右子树移动；直到子树为null
x.parent = xp;//当子树为null时，把节点加到对应的子树上
if (dir <= 0)
xp.left = x;
else
xp.right = x;
root = balanceInsertion(root, x);//平衡红黑树
break;
}
}
}
}
moveRootToFront(tab, root);//把根节点放到桶上并且把根节点放在链表的头部
}备注1解释：当两个的元素的hash值相等如何处理这种碰撞呢？1.判断加入的元素时候实现Comparable接口&&属于同一个类的实例，使用后compareTo方法；2.否则没有实现Comparable接口&&不属于同一个类的实例||比较的结果==0||类型名字一样，则比较原生的Hash值。这个方法在红黑树里面put一个值逻辑基本也是一样的。
下面看下resize方法：
在看源码之前大致看下方法注释，初始化或者扩大两倍数组大小，如果为空，根据threshold初始化大小分配空间。否则，因为我们使用了2的整数次幂的公式，在新的数组,每一个元素的要么会待在原来的桶的位置，或者之前2倍偏移量的位置.
这句话对理解下面的代码很重要，我们知道，index=(cap-1)&hash，而新旧数组的cap 分别为只相差1位，例如：
第一次计算的index：
10100101 11000100 00101101
00000000 00000000 00001111
----------------------------------
00000000 00000000 00001101 第二次计算的index：
10100101 11000100 00101101
00000000 00000000 00011111
----------------------------------
00000000 00000000 00001101 这两次计算的index是一样，另外一个例子：
第一次获取index：
10100101 11000100 00111101
00000000 00000000 00001111
----------------------------------
00000000 00000000 00001101 第二次获取index：
10100101 11000100 00111101
00000000 00000000 00011111
----------------------------------
00000000 00000000 00011101 可以得到：index1=index+oldcap
也就是扩容新增的一位，在对应的hash是位置是0那么就是在原来的index，否则为1时，新的index的偏移量是oldcap，接下来看代码增加理解
/**
* 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;
}
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 { // 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) {//判断最高位是否为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;
}
2388
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
