基本概念
Map集合即Key-Value的集合，前面加个Hash，即散列，无序的。所以HashMap即散着的,无序的Key-Value集合.
HashMap的基本数据结构是数组加链表的。就是这种结构
借鉴一张图，侵权请告知
主要参数: 容量, 加载因子, 扩容阈值 1.8中加入了红黑树相关参数
initialCapacity = HashMap 初始容量
loadFactor=0.75 : 结合空间复杂度,时间复杂度, 用空间利用率和查询效率之间寻找平衡,
threshold : 当前 HashMap 所能容纳键值对数量的最大值，超过这个值，则需扩容
一 : put(K,V)，
核心逻辑在V putVal(int, K, V, boolean, boolean) 方法中。putVal 方法主要做了这么几件事情：
- 当桶数组 table 为空时，通过扩容的方式初始化 table
- 查找要插入的键值对是否已经存在，存在的话根据条件判断是否用新值替换旧值
- 如果不存在，则将键值对链入链表中，并根据链表长度决定是否将链表转为红黑树
- 判断键值对数量是否大于阈值，大于的话则进行扩容操作
借鉴一张图，侵权请告知
接下来上代码:
/**
* 计算key的hash值
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
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，table 被延迟到插入新数据时再进行初始化
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 等于链表中的第一个键值对节点时，则将 e 指向该键值对
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果桶中的引用类型为 TreeNode，则调用红黑树的插入方法
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);
break;
}
// 条件为 true，表示当前链表包含要插入的键值对，终止遍历
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 判断要插入的键值对是否存在 HashMap 中
if (e != null) { // existing mapping for key
V oldValue = e.value;
// onlyIfAbsent 表示是否仅在 oldValue 为 null 的情况下更新键值对的值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 键值对数量超过阈值时，则进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}h= key.hashCode() :取hashCode值,
h^ (h>>>16): 高位参与地位的运算
h& (length-1): 最中计算存储的数组位置
hashmap获取index的运算过程图：
1: 为什么不直接采用经过hashCode（）处理的哈希码 作为 存储数组table的下标位置？
hashMap的初始容量为:16 , hashCode()得到的哈希码与数组范围的大小不匹配
2:为什么采用 哈希码 与运算(&) （数组长度-1） 计算数组下标？
为了解决上面大小不匹配的问题,
3:为什么在计算数组下标前，需对哈希码进行二次处理：扰动处理？
使hash码分布的更加均匀, 是的存储在HashMap中的数组位置更加均匀,
避免出现hash冲突
所有处理的根本目的，都是为了提高 存储key-value的数组下标位置 的随机性 & 分布均匀性，尽量避免出现hash值冲突
二: get()
HashMap 的查找操作比较简，即先定位键值对所在的桶的位置，然后再对链表或红黑树进行查找。通过这两步即可完成查找，该操作相关代码如下：
public V get(Object key) {
Node<K,V> e;
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;
// 1. 定位键值对所在桶的位置
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) {
// 2. 如果 first 是 TreeNode 类型，则调用黑红树查找方法
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// 2. 对链表进行查找
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}当我们明白这个put操作是怎么获取index的时候，get方法也就如出一辙了。看一看就明白了。
三: 扩容
/**
* 初始化table的size或者将table的size翻倍。
* @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) {
//当前长度超过hashMap定义的最大容量，瓶颈设置为Int的最大值
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//当前长度翻倍后，小于hashMap定义的最大容量并且大于默认初始化容量
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1;//容量翻倍
}
//初始化的时候给了默认容量
else if (oldThr > 0)
newCap = oldThr;
//设置默认大小，初始化HashMap即走空构造的时候
else {
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//设置了默认容量的话，我们需要根据loadFactor设置扩容阈值
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) {
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的capacity和threshold。逻辑有点多，慢慢理一下。有一个关键的地方就是 扩容阈值 = table长度 * 负载因子的 这个地方为什么需要设置一个负载因子来算这个扩容阈值。这个涉及到空间以及时间效率的选择。我们可以很简单的想到，如果这个负载因子设置成很大即会提高扩容阈值，空间利用率就会高，但是可想而知就是hash碰撞会变多，导致时间效率就会变低。反之，则空间利用率就低，时间效率会高。
计算好table的capacity和threshold之后，需要转移数组内容。我们可以看到这里出现了其实最懵逼的应该是这个判断条件吧if ((e.hash & oldCap) == 0)。 e.hash&oldCap是什么鬼？我们先来看一个东西
n-1: n表示当前tab的长度 ，key1(hash1): 表示key1的hash值，key2(hash2): 表示key2的hash值
对比的分析我们可以得出下面的
所以，我们在扩容HashMap的时候只需要判断新增那个bit位是0还是1，而e.hash&oldCap这个表达式就是计算出新增的那个bit 是0 还是1，就可以判断出这个节点的对应的数组的下标是原来的那个位置，还是原来的位置+oldCap了
扫一扫
758
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
