文章目录
第一次put值时
1.当new一个HashMap时，HashMap的数组长度为0，只有在第一次put值时，才会给HashMap一个初始化数组长度。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
put方法中会返回一个putVal方法，在这个putVal方法中，通过key计算它的hash值
（hash算法计算方法解析详解参考：https://developer.aliyun.com/article/817686）
static final int hash(Object key) {
int h;
//判断key是否为空，如果为空则返回0否则返回key.hashCode()异或key.hashCode()向右位移16位的值
// 16：hashmap默认容量长度为16，也就是说有16个hash桶
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
然后这个putVal方法，首先它判断tab是否为空，如果为空，则调用resize()方法给数组分配一个长度，在resize()方法中，它会先判断旧数组是否为空，如果为空，则长度为0，然后赋给它一个默认初始化数组长度，这个默认值是1<<4 （1向左位移4位，16），然后再把负载因子和默认初始长度的乘积赋值给它的阈值。
再判断hash桶是否被其他值占用【怎么判断：(n - 1) & hash 表示hashmap是通过（数组长度-1）&（key的hash值）来计算出数组下标，这个hash值就是上面(h = key.hashCode()) ^ (h >>> 16)计算出来的值】，
如果没被占用，则调用newNode()方法new一个新的node节点，将key和value放进去。
（&：按位与）
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//判断tab是否为空，如果为空，则调用resize()方法给数组分配一个长度
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//判断hash桶是否被其他值占用，如果没被占用，则将key value直接放入node节点
if ((p = tab[i = (n - 1) & hash]) == null)
//调用newNode()方法new一个新的node节点，将key value放进去，因为第一次put所以next指针为null
tab[i] = newNode(hash, key, value, null);
else { //如果是第一次put值则不会走这个else中的语句
..........
}
//经过结构修改的次数+1，modCount是hashMap修改次数的计数
++modCount;
//如果size+1大于threshold(阈值：数组长度*负载因子)，则需要给数组扩容
if (++size > threshold)
resize();
//空方法，可扩展
afterNodeInsertion(evict);
return null;
}
new一个新的node节点
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
给数组长度赋值/扩容
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//先判断旧数组是否为空，如果为空，则长度为0
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
//定位新数组长度为0
int newCap, newThr = 0;
if (oldCap > 0) {
.......
}
else if (oldThr > 0) // initial capacity was placed in threshold
......
else { // zero initial threshold signifies using defaults
//第一次put给newCap和newThr赋初始值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
......
}
//将newThr的值赋给阈值
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//初始化newTab，给newTab一个长度
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
.......
}
return newTab;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
第一次put数据后，node节点长度为16.
第二次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;
//tab不为空，跳过
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//判断新key的hashcode是否被占用，如果没被占用，则新建一个node节点，将key和value直接放入node节点中；
//如果被占用，则产生了hash冲突
if ((p = tab[i = (n - 1) & hash]) == null)
//调用newNode()方法new一个新的node节点，将key和value放进去
tab[i] = newNode(hash, key, value, null);
else { //产生hash冲突时，走下面语句
..........
}
//经过结构修改的次数+1，modCount是hashMap修改次数的计数
++modCount;
//如果size+1大于threshold(阈值：数组长度*负载因子)，则需要给数组扩容
if (++size > threshold)
resize();
//空方法，可扩展
afterNodeInsertion(evict);
return null;
}
第二次put，会判断新key的hashcode是否与原有的重复，如果没有重复，则new一个Node节点，并将key和value放到node中；
如果重复，说明出现了hash冲突，然后判断新key和旧key相等不相等，如果相等则将新key的value覆盖到旧key的value上；
如果不相等，则判断数据结构是否为红黑树，如果为红黑树，则将key,value新节点插入树中；
如果不为红黑树，则说明为链表，这时使用for循环，遍历p.next节点，判断链表中是否有相同的key，如果有相同的Key,则将新key的value覆盖到旧key的value上；
如果没有相同的key，则将新节点插入到链表的最后【1.8 尾插法(1.7在遇到hash冲突时，插入链表是头插法)】，
在遍历时，使用一个变量来记录遍历次数，也就是链表的长度，如果链表的长度大于门限值（默认是8），那么就将链表转化成红黑树。
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 { // 出现hash冲突时，即tab[i = (n - 1) & hash] ！=null时
Node<K,V> e; K k;
//判断新put的key和之前put的key是否相等，如果相等，则新key的value值会覆盖老key的value值
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果key不相等，则判断数据结构是否为红黑树，如果为红黑树则直接将新结点插入树中
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//如果key不相等且数据结构为链表时，走for循环，for循环的对象是p的next节点，
//如果p.next节点不为空且有key相同，则找到key相等的节点，用新key的value值替代旧key的value值，
//如果没有相同的key,则往链表的最后添加数据，
//同时使用binCount记录遍历个数，当遍历的个数达到门限值（默认是8）时，链表就要转换成红黑树
else {
for (int binCount = 0; ; ++binCount) {
//p.next为null时，则将新节点插入到链表的最后
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//判断链表的长度是否大于树化负载因子（默认8），大于8时将链表转化成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
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;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
put方法的返回值
如果hashMap中不存在put的key，则put该key时返回的是null;
如果hashMap中存在put的key,则put该key时返回的是旧的value值。
hashMap的底层实现
在1.7的时候，hashMap底层是使用Entry数组和链表实现的,首先它会使用key通过hash算法得到它的hash值，然后再将数组长度-1 与 hash值得到一个数组下标，通过这个数组下标，找到对应位置，看那个位置上有没元素，如果没有，则直接将元素插入该位置；如果有，则发生hash冲突，然后比较这个元素的hash值和key值与位置上原有的是否相同，如果相同则直接覆盖，如果不同，使用拉链法解决。拉链法就是使用一个数组和链表结合，数组的每一格就是一个链表，将冲突的值加入到链表中即可（头插法）。在插入的时候会遍历链表上的数据，如果存在相同的key，则会用新的value替换旧的value,如果不存在，则使用头插法将元素插入到链表头部。
在1.8的时候，hashmap的底层是使用Node数组和链表或红黑树实现的，在解决哈希冲突的结构上发生了比较大的变化。如果链表的长度大于它的阈值，默认是8，然后链表就会转换成红黑树，但是不会立刻转换成红黑树，在转换成红黑树之前会先判断数组的长度，如果数组的长度小于64，则先进行数组的扩容，如果数组的长度大于64，则转换成红黑树。（插入链表使用的是尾插法）
(n - 1) & hash 取模运算为什么不使用%（百分号）而使用&（与）？
因为&运算比%更加高效，当数组长度为2的n次方时，会有
(n - 1) & hash = n % hash
为什么hashMap数组长度要取2的n次方？
因为（数组长度-1）正好相当于一个“低位掩码”——这个掩码的低位最好全是 1，这样 & 操作才有意义，否则结果就肯定是 0，那么 & 操作就没有意义了。
&（只有全为1时，才是1，否则为0）
而且2 的整次幂刚好是偶数，偶数-1 是奇数，奇数的二进制最后一位是 1，保证了 hash &(length-1) 的最后一位可能为 0，也可能为 1（这取决于 hash 值），即 & 运算后的结果可能为偶数，也可能为奇数，这样便可以保证哈希值的均匀性.
& 操作的结果就是将哈希值的高位全部归零，只保留低位值，用来做数组下标访问
例如(16-1)的二进制为00000000 00000000 00001111（高位用 0 来补齐）
假设某Hash值为10100101 11000100 00100101
然后让它们进行与运算
10100101 11000100 00100101
& 00000000 00000000 00001111
----------------------------------
00000000 00000000 00000101
得到 00000000 00000000 00000101 = 5 （十进制）
这表示将hash值为10100101 11000100 00100101的键放在数组的第5位。
为什么取模运算之前要先调用hash方法？
hash方法见上所述
它会返回一个：
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
^ (异或)：同值取0，异值取1
hash 方法是用来做哈希值优化的，把哈希值右移 16 位，也就正好是自己长度的一半，之后与原哈希值做异或运算，这样就混合了原哈希值中的高位和低位，增大了随机性。
hash 方法就是为了增加随机性，让数据元素更加均衡的分布，减少碰撞
hashMap扩容机制
HashMap 的扩容是通过 resize 方法来实现的。
1.初始化一个新数组
2.把原数组的元素复制到新数组中
（1）遍历原数组
（2）判断是否需要重新计算hash
（3）根据新数组的容量和key的hash值来计算元素在新数组中的下标（Jdk8不需要像 JDK 7 那样重新计算 hash，只需要看原来的hash值新增的那个bit是1还是0就好了，是0的话就表示索引没变，是1的话，索引就变成了“原索引+原来的容量”）
（4）复制链表上的元素（1.7使用头插法，1.8使用尾插法）
3.引用新数组
4.重新计算阈值
JDK1.7的扩容机制
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
// transfer（）方法的作用：将原table的node放到新的table中，头插法
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next; //记录e.next的值
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity); //计算e在newTable中的节点，indexFor()作用：计算节点在新table中的下标
e.next = newTable[i]; //把newTable [i]赋值给e.next
newTable[i] = e; //e赋值给newTable[i]
e = next; //next赋值给e
}
}
}
使用头插法的缺点是：
在把原table中的数据复制到新table中时，数据会逆序，这种逆序的扩容方式在多线程时可能出现环形链表。
计算下标的算法很简单，hash值 和 (length-1)按位与，使用length-1的意义在于，length是2的倍数，所以length-1在二进制来说每位都是1，这样可以保证最大的程度的散列hash值，否则，当有一位是0时，不管hash值对应位是1还是0，按位与后的结果都是0，会造成散列结果的重复。
JDK1.8的扩容机制：
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参数，记录新table长度，newCap是oldCap长度的2倍
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;
//循环原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;
//e.next==null，指的是链表中只有一个元素，所以直接把e放入新table，其中的e.hash & (newCap – 1)就是计算e在新table中的位置，和JDK1.7中的indexFor()方法是一样的
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;
}
正常情况下，计算节点在table中的下标的方法是：hash&(oldTable.length-1)，扩容之后，table长度翻倍，计算table下标的方法是hash&(newTable.length-1)，也就是hash&(oldTable.length*2-1)，于是我们有了这样的结论：这新旧两次计算下标的结果，要不然就相同，要不然就是新下标等于旧下标加上旧数组的长度
负载因子
HashMap中负载因子是0.75。
HashMap的初始容量是16, 16x0.75=12 也就是说，当容量达到12时就会进行扩容操作，这个12相当于是扩容机制的一个阈值，当超过这个阈值就会触发扩容机制。
（ArrayList中没有负载因子，它触发扩容机制的时机是：数组放满时）
为什么负载因子是0.75？
是时间和空间的权衡，与泊松分布有关。
负载因子是0.75时，空间利用率比较高，会避免较多的hash冲突，提高空间效率。
多线程下对HashMap进行操作会产生的问题：
多线程下扩容会死循环
HashMap 是通过拉链法来解决哈希冲突的，也就是当哈希冲突时，会将相同哈希值的键值对通过链表的形式存放起来。
JDK 7 时，采用的是头部插入的方式来存放链表的，也就是下一个冲突的键值对会放在上一个键值对的前面（同一位置上的新元素被放在链表的头部）。扩容的时候就有可能导致出现环形链表，造成死循环。
JDK 8 时已经修复了这个问题，扩容时会保持链表原来的顺序。
多线程下put元素会导致元素丢失
但多线程同时执行 put 操作时，如果计算出来的索引位置是相同的，那会造成前一个 key 被后一个 key 覆盖，从而导致元素的丢失。
put和get并发会导致get到null
线程 A 执行put时，因为元素个数超出阈值而出现扩容，线程B 此时执行get，有可能导致这个问题。
可能线程B 此时执行get时数组还没有转移。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
