本文深入解析HashMap数据结构，包括其特点、工作原理、put和get方法流程，以及扩容机制。探讨HashMap如何处理hash碰撞，何时及如何转换链表为红黑树，以优化查找效率。
HashMap基本特点
- HashMap是基于hashing原理，使用put(key,value)存储对象到HashMap中（但是并不保证其顺序），使用get(key)取出对象的一种数据结构。
- HashMap可以接受null键和null值（但是只允许一条记录的键为null，值没做限制）。
- HashMap是非线程安全的。所以在多线程的情况下要使用的话，可以使用Collections.synchronizedMap()来获取一个线程安全的集合，这个方法的原理是在Collections定义了一个SynchronizedMap的内部类，这个类实现了Map接口，在调用方法时加上了synchronized来保证线程同步，相当于在我们调用HashMap时加上synchronized一个意思。
- HashMap的初始容量为16，扩容时是当前容量翻倍即capacity*2。
- 在jdk1.7及之前HashMap都是采用数组+链表的数据结构组成，结合了两者各自的特点，数组寻址容易，插入和删除困难；链表寻址困难，插入和删除容易。而正因为链表长度过长之后他的查找效率会大幅下降，所以在jdk1.8之后当链表长度超过阈值（8）时，将链表转换为红黑树来优化查找的效率。
HashMap实现原理
概述：HashMap是一个由数组、链表和红黑树构成的一种数据结构，它最外面是一个数组，然后每个数组的元素都是一个Node节点，同一个Hash位置的Node节点延长构成了链表，当着个链表的长度过长超出阈值后就会自动转换为红黑树。首先在插入的过程中，会计算一个hash值，将其作为Node的key同时也确定了在数组中存放的位置。但是如果算出了相同的hash值也就是常说的hash碰撞，那么该放哪儿呢？这里用到我们的链表了，当有相同hash值的时候，它会在数组相应位置以链表的形式把这些hash值相同的内容插入。那到这里我们一般的存储过程就是这样了，还要红黑树干什么呢？其中 红黑树的引入就是为了解决当有大量的hash碰撞的产生，如果都按我们之前的存储方式的话，hashmap就变成了一个简单的线性结构，和链表相同（查找事件复杂度O/N）了，所以后面在超过阈值之后就转化为红黑树（O/logn）。
在大致了解了HashMap的基本工作原理后，我们可以发现几个问题：
- 什么时候将链表转化为红黑树，怎么转？
- 它是如何避免发生hash碰撞的？
- put、get原理
下面就一一看下这几个问题
- put原理
public V put(K key, V value) {
//调用putVal并将key执行hash算法
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的赋值，发现只有在初始化时赋了值
//Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//table = newTab;
//判断当前数组是否创建
if ((tab = table) == null || (n = tab.length) == 0)
//没创建则调用resize进行初始化
n = (tab = resize()).length;
//根据当前 key 的 hashcode 定位到具体的桶中并判断是否为空
if ((p = tab[i = (n - 1) & hash]) == null)
//为空则直接在当前的数组位置创建Node节点
tab[i] = newNode(hash, key, value, null);
//这个else里面全都是有hash冲突的
else {
//如果不为空，则代表数组当前位置已经有值了，所以要以链表或者红黑树的方式插入Node
Node<K,V> e; K k;
//查看当前key和它对应的hashcode是否在已存在位置有了
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 {
//如果是链表，则要将新的Node插入到当前桶中的链表后面
for (int binCount = 0; ; ++binCount) {
//找到空位置节点
if ((e = p.next) == null) {
//将新的Node节点插入到该位置
p.next = newNode(hash, key, value, null);
//查看当前链表长度是否大于阈值（从-1开始的所以-1）
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//如果大于的话就将链表转换为红黑树结构
treeifyBin(tab, hash);
break;
}
//如果在遍历过程中找到相同的key则直接退出
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//工作节点P存放最后的结果
p = e;
}
}
//如果存在相同的key则直接将值覆盖
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//用传入的值去覆盖e的值
e.value = value;
afterNodeAccess(e);
//但是返回旧的值
return oldValue;
}
}
//如果没有hash冲突（就没有key的重复），将修改次数+1
++modCount;
//将size + 1 并判断是否需要扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
上面我已经基本每一行按我的理解写注释写的清清楚楚了，接着我们还是整体梳理下Hashmap的put流程，首先将其key做hash函数，再传入putVal进行真正的put操作；首先判断当前数组是否为null，为null的话则调用resize方法初始化数组；然后通过当前key的hashcode定位到桶中是否有元素存在，没有就将其放在该桶的第一个位置，有的话就说明产生了hash冲突了，所以接下来就是处理hash冲突 阶段；先看对应的key是否已经存在，存在的话直接将其覆盖，不存在的话就说明要将其放在新的位置了；首先判断是否是树节点，是的话则调用红黑树的put处理方法，不是的话说明是链表，则遍历该链表下的节点找到有空位则新建并将其放入，处理完之后如果e是有值的则说明发生了hash碰撞，并且存在相同的key，这时候直接将传入的value覆盖旧值；整体流程没有发生冲突的话将操作数+1，并且将总数+1，再判断是否需要扩容。
- 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;
//先判断当前数组不为null
if ((tab = table) != null && (n = tab.length) > 0 &&
//根据hash值定位到所在的桶，先看第一个位置是否为null
(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) {
//如果当前节点为树状节点，交给红黑树的get处理
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
//判断key和key的hash，找到则返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
//没找到则返回null
return null;
}
看完了put流程，get流程就很简单了，首先判断当前数组不为null，然后根据传入的hash值定位到所在的桶，先检查该桶的第一个节点，找到就返回，没有找到就继续，然后判断是否为树状节点，true：交给红黑树处理，false：遍历链表直到最后。
- HashMap什么时候会扩容？怎样扩容？扩容有什么影响？
我们要想知道HashMap什么时候会扩容的话，得先去分析它的初始容量和触发扩容的临界条件，接下来就进入源码分析一下。
//默认大小16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大size
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认扩容因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//8为是否转换为红黑树的链表长度临界值
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
//红黑树的最小长度64
static final int MIN_TREEIFY_CAPACITY = 64;
看到了它的这些参数再结合我们之前对put源码的分析，我们了解到当size超过了threshold就会发生扩容，接下来看看是怎么扩容的，分析一下resize源码
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//老的容量大于0
if (oldCap > 0) {
//老的容量大于最大容量了
if (oldCap >= MAXIMUM_CAPACITY) {
//将threshold设置为最大值
threshold = Integer.MAX_VALUE;
//也不扩容了，就这样返回，要碰撞就碰
return oldTab;
}
//旧的容量是大于初始容量的并且新的容量如果在旧容量*2后还小于最大容量
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//新容量大小没问题，将threshold也*2
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;
//threshold = 负载因子 * 初始容量
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;
//old中还有值则将old里面的放到新的当中去
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;
}
扫一扫
5529
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
