HashMap笔记
基本数据结构
JDK1.8之前：数组加链表
JDK1.8及之后有两种情况：
1）在数组长度小于64时：是数组加链表
2）在数组长度大于64时：当冲突位置的（桶）链表长度大于8时，会将链表转化为红黑树，此时为数组加红黑树，红黑树的节点小于6的时候又会重新置为链表
非线程安全的
没有任何保证线程安全的机制
继承关系
继承 AbstractMap<K,V>抽象类
实现Map<K,V>, Cloneable, Serializable三个接口
AbstractMap<K,V>也继承自Map<K,V>接口，所以继承了抽象类就不再需要继承接口了，实际上看源码会发现几乎所有的集合都有这样的问题，开发者说这是刚开始设计的一个错误，但是并不值得去修改就没有动这块
几个属性
transient Node<K,V>[] table;//实际存储数据的数组
transient Set<Map.Entry<K,V>> entrySet;//缓存entrySet()方法的结果，注释有个for keySet(),values(),不知道什么意思，看代码没看到有什么关系
transient int size;//实际存储的个数
transient int modCount;//修改的次数，实际上相当于版本号，为了迭代器遍历时的快速失败准备
int threshold;//阈值，size超过这个值要扩容
final float loadFactor;//加载因子，table.length*loadFactor = threshold
装载因子
默认0.75，当实际存储内容>数组长度*装载因子时会进行扩容
构造函数
默认无参的构造函数，只做了一件事，指定装载因子为默认的0.75，实际Node数组的初始化在resize()方法里面，请看后面的扩容部分有详细的分析
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
有参的构造函数，只给定初始容量的也会走到这里，只给定初始容量的方法，所以只对这个方法进行分析
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)//给定初始值小于0，抛异常
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)//给定值大于最大值，赋值成最大值
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))//加载因子赋值判断，不小于等于0并且不是null
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;//给加载因子赋值
//将根据参数计算出来的容量赋值给当前实例的阈值，下面resize()方法解释为什么这样做
this.threshold = tableSizeFor(initialCapacity);
}
逻辑很简单，做了一些判断赋值，然后有个疑惑就是threshold的赋值，这个会在下面的resize()方法分析的时候给予解释
传入一个Map的实例构造hashMap对象
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);//调用下面的方法进行添加
}
/**
* Implements Map.putAll and Map constructor
*
* @param m the map
* @param evict false when initially constructing this map, else
* true (relayed to method afterNodeInsertion).
*/
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {//当传入的长度大于0的时候开始存
if (table == null) { // pre-size
//初始化当前实例
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
//将根据参数计算出来的容量赋值给当前实例的阈值，下面resize()方法解释为什么这样做
threshold = tableSizeFor(t);
}
else if (s > threshold)//如果s大于当前实例的阈值，调用resize()，不知道什么时候会走到这里
resize();
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
//然后就调用putVal方法了，后面有对这个方法的分析
putVal(hash(key), key, value, false, evict);
}
}
}
如何实现的2的N次幂的长度，tableSizeFor(int cap)方法
默认的构造函数的就不说了，这里来说一说调用指定长度的构造方法时，是如何搞定的
先上源码
这里在进行一番操作后，就正好是比指定值大的最小的2的N次幂
首先
n=cap - 1;
这块防止输入的数正好是2、4、8、16、32···，反正就是防止你正好输入了2的N次幂的
然后后面一顿右移然后按位或，这个操作就比较神奇了，不管你是几，这样一番操作后从输入的数的最高位开始，后面全是1，那就会出现0001、0011、0111，就是1,3,7，在最后返回结果之前加1正好就是2的N次幂了
这里返回之前还有一些判断，如果结果是0，就给1个容量，因为前面做了减一的操作，所以至少给个1
如果结果大于最大值则返回最大值，最大值在源码中也有就是1左移30位
计算索引的方法
目标结果：hash%n的值
但是，直接求余的运算非常慢，所以这里采用了另外一种等效的方法
方法就是：当前数组的长度减一然后按位与hashCode
设当前数组的长度为n
此时要存的key的下标 = (n-1) & hashCode
为什么这样按位与就可以与取余的结果一样了呢？因为HashMap的底层设计数组的长度必定为2的N次方，而2的N次幂减一的二进制数除了最高位，后面都是1，此时按位与的结果正好就是hashCode%n值，真的是一个非常巧妙的办法！
假设n是默认值16，那么他的二进制为
0000 0000 0000 0000 0000 0000 0001 0000
n-1 为
0000 0000 0000 0000 0000 0000 0000 1111
假设要插入键的hash值为
0010 1101 0110 1100 1010 1101 1111 0101
这个hash值是HashMap类的hash(Object key)方法计算出来的，这里先不用关心怎么算的，在下面【计算hash值的方法】有解释
那么(n-1)&hash
为什么这样就正好和hash%n的结果一样了呢，我是这样理解的
以此类推，可以看出来，只要是从n的二进制数的1所在的位置开始，hash值的高位就正好能除开n，而hash值比1低的位就是余数，前提是n的二进制数里面只有一个1，如果二进制数中只有一个1的话那正好就是2的n次幂，所以n也必须是2的N次幂才能正好是 (n-1)&hash = hash%n
复习：
按位与：当两个值都为1时才为1
计算hash值的方法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里明显可以看出hashMap可以存储null的键，对于null的键hash值给的是0
不为null的键的hash值计算方法：
键的hashCode给h，然后使h和h右移16位进行异或计算
复习：
异或：00的0，11得0，10得1，01得1，相同就是0，不同就为1
为什么要这样运算呢，下面我举个例子
假设有如下两个hashCode
这两个hashCode没有经过hash(Object key)方法计算直接使用
出现了hash冲突，很明显这是我们不希望看到的结果，如果使用了 (h = key.hashCode()) ^ (h >>> 16) 计算了呢
首先来重新计算一下两个hash值
然后再与n-1按位与
终于是我们想看到的结果了
所以这样做是为了是尽量避免hash碰撞，因为当数组长度比较小的时候，计算数组下标的时候只会用到低位的值，而两个hash低位值相同的时候就很容易出现hash碰撞，这里将高位的值右移到低位然后进行异或操作的时候，使高位的值也得到了利用，提供更好的散列性
put方法
先上源码，put方法也是调用这个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)//如果还未初始化过，那么初始化
n = (tab = resize()).length;
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;//如果当前插入的key已存在，那么当前指针给e，后面有修改的处理
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) {
//如果到最后仍然没有已经存在的key，那么插到链表最后面
p.next = newNode(hash, key, value, null);
//如果大于等于边界值，调用转化为红黑树的方法
//实际treeifyBin方法里面还是有一层判断的，如果数组长度小于64是会进行扩容操作，而不是转换为树
//因为刚刚加进去的元素并没有算到binCount里面
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果当前遍历到的节点的key和要插入的key是一样的，那么结束遍历，同样这时候e指向的是要修改的节点，后面会进行修改的处理
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//下面是他原本的英文注释，看意思很明显，就是要插入的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;//记录对当前HashMap实例的修改次数，每一次添加、修改、删除都会加加
if (++size > threshold)//判断当前的实际存储元素的个数是否达到边界值，达到边界值那么就扩容
resize();
afterNodeInsertion(evict);
return null;
}
1.先通过hash值计算出应该映射到哪个桶
2.如果没有hash碰撞，直接插入
3.如果有碰撞了，处理冲突
(1) 如果该桶使用红黑树，则调用红黑树的方法插入数据
(2) 否则采用传统的链式方法插入，达到阈值（链表长度大于8，并且数组长度大于64）后转换为红黑树
4.如果是重复的键，那么替换value
5.如果size大于阈值threshold，进行扩容
扩容，resize()方法，兼职初始化
这是扩容方法，实际上第一次调用put的时候也会调用这个方法，所以这个方法还兼职了初始化的工作，里面有一个点需要注意，下面我会说明，同样先看我给加了备注的源码
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//存储旧的table
//如果旧的table不存在旧的长度就记为0，如果存在就记旧的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//存储旧的阈值
int oldThr = threshold;
//新的数组长度和阈值
int newCap, newThr = 0;
//如果旧的数组长度大于0，说明初始化过了
if (oldCap > 0) {
//旧的数组长度大于等于最大值，那么给阈值设置为int的最大值，return旧的table，结束方法
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//如果旧数组长度*2小于最大值，并且旧数组长度大于等于默认值，那么新阈值等于旧阈值*2
//容量翻倍，加载因子不变，阈值肯定也会跟着翻倍，直接左移一位就可以，但是为什么要大于默认值才跟着翻倍，同样源码后面解释
//左移一位就是翻倍，应该不再需要解释了
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;
//使用无参的构造函数创建的HashMap,第一次put会走到这个逻辑，当旧数组长度和旧阈值都不大于0，那么新的数组长度和阈值都给上默认值
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的阈值等于0，说明上面的逻辑都没有走进去，其实走进第一个if里面了
//然后旧的容量小于默认值，或者左移一位后大于最大值，导致新的阈值没有给赋值，下面就是处理这种情况的
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数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;//赋值给当前的节点
if (oldTab != null) {
//循环旧的Node数组
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
//因为数组扩容后是扩容前的二倍长度，所以n-1的二进制多了一位1
//那么按位与的时候，数据要么在原位置，要么在原索引加旧长度的位置
//创建两个链表，分别为高位和低位的链表，后面有给新的Node数组赋值时的高低位链表分析
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//直接与旧长度按位与，结果为0，元素就是在原位置，否则元素在原索引加旧长度的位置
if ((e.hash & oldCap) == 0) {
//如果游标为空，那么证明没记录过，把头节点指针指到当前节点
if (loTail == null)
loHead = e;
//否则将游标的next指向当前节点
else
loTail.next = e;
loTail = e;//将游标指向当前节点
}
else {//和if的逻辑一样，只不过是高位的
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;//返回新数组
}
上面分析这一段代码的时候有个疑惑，我们先看一下HashMap有参的构造方法
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//将根据参数计算出来的容量赋值给当前实例的阈值，why？
this.threshold = tableSizeFor(initialCapacity);
}
然后再来看有问题的这段代码
if (oldCap > 0) {
//省略,主要看下面else if里面
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;//将旧的阈值设定为新的数组容量
这段代码的意思就是，如果旧的容量不大于0，但阈值却大于0的时候，使新的容量等于旧的阈值
这就解释的通了，我也认为设计者不会赋值一段无意义的代码
由于我们调用有参的构造函数创建HashMap都会调用到上面的构造方法，并且上面的构造方法没有给Node数组进行初始化，那么就是HashMap第一次put的时候会走到这个else if的逻辑里面，然后将之前计算的数组长度给赋值进去
这样设计其实是为了在构造函数中不初始化Node数组，但是记录需要初始化的容量，然后在第一次put的时候再初始化真正存储数据的Node数组，很明显这样处理违背了单一职责的原则，而且在构造函数赋值threshold的时候没有给备注说明，我认为这非常容易给后面阅读源码和维护的人造成困惑。
给新的Node数组赋值时的高低位链表分析
我们只需要看红框的位置，如果hash值的二进制数在这一位是0，那么扩容后就是在原位置，如果这一位是1，那么扩容后就是原索引加上旧的长度的位置，那么如何知道hash值的这个位置是0还是1呢，这时候旧的长度派上用场了，旧的数组长度二进制数正好只有这个位置是1，那么将hash值与旧的长度按位与就行了
get方法
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;
}
仔细一看，这不就跟是putVal方法的第一个else里面差不多么，没啥好说的，跳过
remove方法
还是源码开始分析，物品们正常调用的是上面的remove方法，然后他调用removeNode方法
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
//tab就是table,p是游标，n是table.length，index是索引
Node<K,V>[] tab; Node<K,V> p; int n, index;
//table不为null，并且长度大于0，并且要删除键算出的桶不是null，才进行删除操作
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
//如果最后查找到的话，node指向要删除的节点
//此时p指向根节点，如果p正好是我们要删除的节点，那么node指向p
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
//如果根节点不是要删除的节点，那么遍历桶内数据
else if ((e = p.next) != null) {//因为树节点要用到p,所以这块要用e来接next
if (p instanceof TreeNode)//如果是树节点，那么调用树的方法获取节点
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {//不是树节点的话遍历链表获取要删除的节点
do {
//如果找到要删除的节点，那么node指向该节点
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
//游标下移
p = e;
} while ((e = e.next) != null);
}
}
//处理删除，如果查找到了，那么一定会走进去这块的逻辑，因为matchValue参数给的值是false
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)//如果node等于p，那么要删除的是链表的根节点
tab[index] = node.next;
else
p.next = node.next;//否则删除该节点
++modCount;//记录修改次数（版本号）
--size;//元素个数减一
afterNodeRemoval(node);
return node;
}
}
return null;
}
基本步骤在注释里面有了，还是看注释吧
建议的初始容量设置
根据阿里巴巴开发手册的建议，知道有多少个元素一定要调用设置初始容量的构造方法，避免扩容，假设要存储x个元素，那么建议用如下方式计算初始容量
x/0.75+1.0F
这样避免了在添加的过程中发生扩容
假设要存7个，直接给值的话会创建初始长度为8的数组，但是存储的时候就发生了扩容，经过这个方法计算后 9.3333 + 1.0 = 10.3333
这样的话就会创建16个长度的数组，避免了扩容的操作
521
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
