点击上方 Java后端,选择 设为星标
优质文章,及时送达
HashMap是基于哈希表实现的,每一个元素是一个key-value对,其内部通过单链表解决冲突问题,容量不足(超过了阀值)时,同样会自动增长.
HashMap是非线程安全的,只适用于单线程环境,多线程环境可以采用并发包下的concurrentHashMap
HashMap 实现了Serializable接口,因此它支持序列化,实现了Cloneable接口,能被克隆
HashMap是基于哈希表的Map接口的非同步实现.此实现提供所有可选的映射操作,并允许使用null值和null键.此类不保证映射的顺序,特别是它不保证该顺序恒久不变.
Java8中又对此类底层实现进行了优化,比如引入了红黑树的结构以解决哈希碰撞
在Java中,最基本的结构就是两种,一个是数组,另外一个是模拟指针(引用),所有的数据结构都可以用这两个基本结构来构造,HashMap也不例外. HashMap实际上是一个"链表散列"的数据结构,即数组和链表的结合体.
HashMap的主结构类似于一个数组,添加值时通过key确定储存位置.
每个位置是一个Entry的数据结构,该结构可组成链表.
当发生冲突时,相同hash值的键值对会组成链表.
这种数组+链表的组合形式大部分情况下都能有不错的性能效果,Java6、7就是这样设计的. 然而,在极端情况下,一组(比如经过精心设计的)键值对都发生了冲突,这时的哈希结构就会退化成一个链表,使HashMap性能急剧下降.
所以在Java8中,HashMap的结构实现变为数组+链表+红黑树
可以看出,HashMap底层就是一个数组结构
数组中的每一项又是一个链表
当新建一个HashMap时,就会初始化一个数组.
HashMap使用三大集合和三种迭代子来轮询其Key、Value和Entry对象
public class HashMapExam {public static void main(String[] args) {Map map &#61; new HashMap(16);for (int i &#61; 0; i <15; i&#43;&#43;) {map.put(i, new String(new char[]{(char) (&#39;A&#39;&#43; i)}));}System.out.println("&#61;&#61;&#61;&#61;&#61;&#61;keySet&#61;&#61;&#61;&#61;&#61;&#61;&#61;");Set set &#61; map.keySet();Iterator iterator &#61; set.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}System.out.println("&#61;&#61;&#61;&#61;&#61;&#61;values&#61;&#61;&#61;&#61;&#61;&#61;&#61;");Collection values &#61; map.values();Iterator stringIterator&#61;values.iterator();while (stringIterator.hasNext()) {System.out.println(stringIterator.next());}System.out.println("&#61;&#61;&#61;&#61;&#61;&#61;entrySet&#61;&#61;&#61;&#61;&#61;&#61;&#61;");for (Map.Entry entry : map.entrySet()) {System.out.println(entry);}}
}
//默认的初始容量16,且实际容量是2的整数幂static final int DEFAULT_INITIAL_CAPACITY &#61; 1 <<4;//最大容量(传入容量过大将被这个值替换)static final int MAXIMUM_CAPACITY &#61; 1 <<30;// 默认加载因子为0.75(当表达到3/4满时,才会再散列),这个因子在时间和空间代价之间达到了平衡.更高的因子可以降低表所需的空间,但是会增加查找代价,而查找是最频繁操作static final float DEFAULT_LOAD_FACTOR &#61; 0.75f;//桶的树化阈值&#xff1a;即 链表转成红黑树的阈值&#xff0c;在存储数据时&#xff0c;当链表长度 >&#61; 8时&#xff0c;则将链表转换成红黑树static final int TREEIFY_THRESHOLD &#61; 8;// 桶的链表还原阈值&#xff1a;即 红黑树转为链表的阈值&#xff0c;当在扩容&#xff08;resize&#xff08;&#xff09;&#xff09;时&#xff08;HashMap的数据存储位置会重新计算&#xff09;&#xff0c;在重新计算存储位置后&#xff0c;当原有的红黑树内数量 <&#61; 6时&#xff0c;则将 红黑树转换成链表static final int UNTREEIFY_THRESHOLD &#61; 6;//最小树形化容量阈值&#xff1a;即 当哈希表中的容量 > 该值时&#xff0c;才允许树形化链表 &#xff08;即 将链表 转换成红黑树&#xff09;
因为红黑树的平均查找长度是log(n)&#xff0c;长度为8的时候&#xff0c;平均查找长度为3&#xff0c;如果继续使用链表&#xff0c;平均查找长度为8/2&#61;4&#xff0c;这才有转换为树的必要
链表长度如果是小于等于6&#xff0c;6/2&#61;3&#xff0c;虽然速度也很快的&#xff0c;但是转化为树结构和生成树的时间并不会太短
还有选择6和8&#xff0c;中间有个差值7可以有效防止链表和树频繁转换
假设一下&#xff0c;如果设计成链表个数超过8则链表转换成树结构&#xff0c;链表个数小于8则树结构转换成链表&#xff0c;如果一个HashMap不停的插入、删除元素&#xff0c;链表个数在8左右徘徊&#xff0c;就会频繁的发生树转链表、链表转树&#xff0c;效率会很低。
// 为了避免扩容/树形化选择的冲突&#xff0c;这个值不能小于 4 * TREEIFY_THRESHOLD// 小于该值时使用的是扩容哦!!!static final int MIN_TREEIFY_CAPACITY &#61; 64;// 存储数据的Node数组,长度是2的幂.// HashMap采用链表法解决冲突&#xff0c;每一个Node本质上是一个单向链表//HashMap底层存储的数据结构,是一个Node数组.上面得知Node类为元素维护了一个单向链表.至此,HashMap存储的数据结构也就很清晰了:维护了一个数组,每个数组又维护了一个单向链表.之所以这么设计,考虑到遇到哈希冲突的时候,同index的value值就用单向链表来维护//与 JDK 1.7 的对比&#xff08;Entry类&#xff09;&#xff0c;仅仅只是换了名字transient Node[] table;// HashMap的底层数组中已用槽的数量transient int size;// HashMap的阈值&#xff0c;用于判断是否需要调整HashMap的容量&#xff08;threshold &#61; 容量*加载因子&#xff09;int threshold;// 负载因子实际大小final float loadFactor;// HashMap被改变的次数transient int modCount;// 指定“容量大小”和“加载因子”的构造函数,是最基础的构造函数public HashMap(int initialCapacity, float loadFactor) {if (initialCapacity <0)throw new IllegalArgumentException("Illegal initial capacity: " &#43;initialCapacity);// HashMap的最大容量只能是MAXIMUM_CAPACITYif (initialCapacity > MAXIMUM_CAPACITY)initialCapacity &#61; MAXIMUM_CAPACITY;//负载因子须大于0if (loadFactor <&#61; 0 || Float.isNaN(loadFactor))throw new IllegalArgumentException("Illegal load factor: " &#43;loadFactor);// 设置"负载因子"this.loadFactor &#61; loadFactor;// 设置"HashMap阈值",当HashMap中存储数据的数量达到threshold时,就需将HashMap的容量加倍this.threshold &#61; tableSizeFor(initialCapacity);}
上面的tableSizeFor有何用?
tableSizeFor方法保证函数返回值是大于等于给定参数initialCapacity最小的2的幂次方的数值
static final int tableSizeFor(int cap) {int n &#61; cap - 1;n |&#61; n >>> 1;n |&#61; n >>> 2;n |&#61; n >>> 4;n |&#61; n >>> 8;n |&#61; n >>> 16;return (n &#61; MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n &#43; 1;}
a |&#61; b 等同于 a &#61; a|b
逐行分析
int n &#61; cap - 1
给定的cap 减 1,为了避免参数cap本来就是2的幂次方,这样一来,经过后续操作&#xff0c;cap将会变成2 * cap,是不符合我们预期的
n |&#61; n >>> 1
n >>> 1 : n无符号右移1位,即n二进制最高位的1右移一位
n | (n >>> 1) 导致 n二进制的高2位值为1
目前n的高1~2位均为1
n |&#61; n >>> 2
n继续无符号右移2位
n | (n >>> 2) 导致n二进制表示的高34位经过运算值均为1
目前n的高14位均为1
n |&#61; n >>> 4
n继续无符号右移4位
n | (n >>> 4) 导致n二进制表示的高58位经过运算值均为1
目前n的高18位均为1
n |&#61; n >>> 8
n继续无符号右移8位
n | (n >>> 8) 导致n二进制表示的高916位经过运算值均为1
目前n的高116位均为1
可以看出,无论给定cap(cap
至此tableSizeFor如何保证cap为2的幂次方已经显而易见了,那么问题来了
主要与HashMap中的数据存储有关.
在Java8中,HashMap中key的Hash值由Hash(key)方法计得
HashMap中存储数据table的index是由key的Hash值决定的.
在HashMap存储数据时,我们期望数据能均匀分布,以防止哈希冲突.
自然而然我们就会想到去用%取余操作来实现我们这一构想
取余(%)操作 : 如果除数是2的幂次则等价于与其除数减一的与(&)操作.
这也就解释了为什么一定要求cap要为2的幂次方.再来看看table的index的计算规则&#xff1a;
等价于:index &#61; e.hash % newCap
采用二进制位操作&,相对于%,能够提高运算效率,这就是cap的值被要求为2幂次的原因
static class Node implements Map.Entry {final int hash;final K key;V value;Node next;Node(int hash, K key, V value, Node next) {this.hash &#61; hash;this.key &#61; key;this.value &#61; value;this.next &#61; next;}public final K getKey() { return key; }public final V getValue() { return value; }public final String toString() { return key &#43; "&#61;" &#43; value; }public final int hashCode() {return Objects.hashCode(key) ^ Objects.hashCode(value);}public final V setValue(V newValue) {V oldValue &#61; value;value &#61; newValue;return oldValue;}public final boolean equals(Object o) {if (o &#61;&#61; this)return true;if (o instanceof Map.Entry) {Map.Entry e &#61; (Map.Entry)o;if (Objects.equals(key, e.getKey()) &&Objects.equals(value, e.getValue()))return true;}return false;}}
Node 类是HashMap中的静态内部类,实现Map.Entry接口.定义了key键、value值、next节点,也就是说元素之间构成了单向链表.
static final class TreeNode extends LinkedHashMap.Entry {TreeNode parent; // red-black tree linksTreeNode left;TreeNode right;TreeNode prev; // needed to unlink next upon deletionboolean red;TreeNode(int hash, K key, V val, Node next) {}// 返回当前节点的根节点final TreeNode root() {for (TreeNode r &#61; this, p;;) {if ((p &#61; r.parent) &#61;&#61; null)return r;r &#61; p;}}}
红黑树结构包含前、后、左、右节点&#xff0c;以及标志是否为红黑树的字段
此结构是Java8新加的
Java 8中的散列值优化函数
只做一次16位右位移异或
key.hashCode()函数调用的是key键值类型自带的哈希函数&#xff0c;返回int型散列值
理论上散列值是一个int型&#xff0c;如果直接拿散列值作为下标访问HashMap主数组的话&#xff0c;考虑到2进制32位带符号的int范围大概40亿的映射空间。只要哈希函数映射得比较均匀松散&#xff0c;一般应用是很难出现碰撞的。
但问题是一个40亿长度的数组&#xff0c;内存是放不下的.HashMap扩容之前的数组初始大小才16,所以这个散列值是不能直接拿来用的.
用之前还要先做对数组的长度取模运算&#xff0c;得到的余数才能用来访问数组下标
源码中模运算就是把散列值和数组长度做一个"与"操作&#xff0c;
这也正好解释了为什么HashMap的数组长度要取2的整次幂
因为这样&#xff08;数组长度-1&#xff09;正好相当于一个“低位掩码”
“与”操作的结果就是散列值的高位全部归零&#xff0c;只保留低位值&#xff0c;用来做数组下标访问
以初始长度16为例&#xff0c;16-1&#61;15
2进制表示是00000000 00000000 00001111
和某散列值做“与”操作如下&#xff0c;结果就是截取了最低的四位值
但这时候问题就来了,这样就算我的散列值分布再松散,要是只取最后几位的话,碰撞也会很严重
这时候“扰动函数”的价值就体现出来了
右位移16位&#xff0c;正好是32位一半&#xff0c;自己的高半区和低半区做异或&#xff0c;就是为了混合原始hashCode的高位和低位&#xff0c;以此来加大低位的随机性
而且混合后的低位掺杂了高位的部分特征&#xff0c;这样高位的信息也被变相保留下来。
index的运算规则是e.hash & (newCap - 1)
newCap是2的幂,所以newCap - 1的高位全0
若e.hash值只用自身的hashcode,index只会和e.hash的低位做&操作.这样一来,index的值就只有低位参与运算,高位毫无存在感,从而会带来哈希冲突的风险
所以在计算key的hashCode时,用其自身hashCode与其低16位做异或操作
这也就让高位参与到index的计算中来了,即降低了哈希冲突的风险又不会带来太大的性能问题
①.判断键值对数组table[i]是否为空或为null&#xff0c;否则执行resize()进行扩容
②.根据键值key计算hash值得到插入的数组索引i&#xff0c;如果table[i]&#61;&#61;null&#xff0c;直接新建节点添加&#xff0c;转向⑥&#xff0c;如果table[i]不为空&#xff0c;转向③
③.判断table[i]的首个元素是否和key一样&#xff0c;如果相同直接覆盖value&#xff0c;否则转向④&#xff0c;这里的相同指的是hashCode以及equals
④.判断table[i] 是否为treeNode&#xff0c;即table[i] 是否是红黑树&#xff0c;如果是红黑树&#xff0c;则直接在树中插入键值对&#xff0c;否则转向⑤
⑤.遍历table[i]&#xff0c;判断链表长度是否大于8&#xff0c;大于8的话把链表转换为红黑树&#xff0c;在红黑树中执行插入操作&#xff0c;否则进行链表的插入操作&#xff1b;遍历过程中若发现key已经存在直接覆盖value即可
⑥.插入成功后&#xff0c;判断实际存在的键值对数量size是否超多了最大容量threshold&#xff0c;如果超过&#xff0c;执行resize()扩容
public V put(K key, V value) {// 对key的hashCode()做hashreturn putVal(hash(key), key, value, false, true);}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {Node[] tab; Node p; int n, i;// 步骤① tab为空则调用resize()初始化创建if ((tab &#61; table) &#61;&#61; null || (n &#61; tab.length) &#61;&#61; 0)n &#61; (tab &#61; resize()).length;// 步骤② 计算index,并对null做处理//tab[i &#61; (n - 1) & hash对应下标的第一个节点if ((p &#61; tab[i &#61; (n - 1) & hash]) &#61;&#61; null)// 无哈希冲突的情况下,将value直接封装为Node并赋值tab[i] &#61; newNode(hash, key, value, null);else {Node e; K k;// 步骤③ 节点的key相同,直接覆盖节点if (p.hash &#61;&#61; hash && ((k &#61; p.key) &#61;&#61; key || (key !&#61; null && key.equals(k))))e &#61; p;// 步骤④ 判断该链为红黑树else if (p instanceof TreeNode)// p是红黑树类型&#xff0c;则调用putTreeVal方式赋值e &#61; ((TreeNode)p).putTreeVal(this, tab, hash, key, value);// 步骤⑤ p非红黑树类型,该链为链表else {// index 相同的情况下for (int binCount &#61; 0; ; &#43;&#43;binCount) {if ((e &#61; p.next) &#61;&#61; null) {// 如果p的next为空,将新的value值添加至链表后面p.next &#61; newNode(hash, key, value, null);if (binCount >&#61; TREEIFY_THRESHOLD - 1)// 如果链表长度大于8,链表转化为红黑树,执行插入treeifyBin(tab, hash);break;}// key相同则跳出循环if (e.hash &#61;&#61; hash && ((k &#61; e.key) &#61;&#61; key || (key !&#61; null && key.equals(k))))break;//就是移动指针方便继续取 p.nextp &#61; e;}}if (e !&#61; null) { // existing mapping for keyV oldValue &#61; e.value;//根据规则选择是否覆盖valueif (!onlyIfAbsent || oldValue &#61;&#61; null)e.value &#61; value;afterNodeAccess(e);return oldValue;}}&#43;&#43;modCount;// 步骤⑥:超过最大容量,就扩容if (&#43;&#43;size > threshold)// size大于加载因子,扩容resize();afterNodeInsertion(evict);return null;}
在构造函数中最多也只是设置了initialCapacity、loadFactor的值,并没有初始化table,table的初始化工作是在put方法中进行的.
扩容(resize)就是重新计算容量,向HashMap对象里不停的添加元素,内部的数组无法装载更多的元素时,就需要扩大数组的长度.
当然Java里的数组是无法自动扩容的,方法是使用一个新的数组代替已有的容量小的数组
remove(key) 方法 和 remove(key, value) 方法都是通过调用removeNode的方法来实现删除元素的 在JDK1.7及以前的版本中&#xff0c;HashMap里是没有红黑树的实现的&#xff0c;在JDK1.8中加入了红黑树是为了防止哈希表碰撞攻击&#xff0c;当链表链长度为8时&#xff0c;及时转成红黑树&#xff0c;提高map的效率 如果某个桶中的记录过大的话&#xff08;当前是TREEIFY_THRESHOLD &#61; 8&#xff09;&#xff0c;HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好&#xff0c;是O(logn)&#xff0c;而不是糟糕的O(n)。它是如何工作的&#xff1f;前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面&#xff0c;这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树&#xff0c;使用哈希值作为树的分支变量&#xff0c;如果两个哈希值不等&#xff0c;但指向同一个桶的话&#xff0c;较大的那个会插入到右子树里。如果哈希值相等&#xff0c;HashMap希望key值最好是实现了Comparable接口的&#xff0c;这样它可以按照顺序来进行插入。这对HashMap的key来说并不是必须的&#xff0c;不过如果实现了当然最好。如果没有实现这个接口&#xff0c;在出现严重的哈希碰撞的时候&#xff0c;你就并别指望能获得性能提升了。 这个性能提升有什么用处&#xff1f;比方说恶意的程序&#xff0c;如果它知道我们用的是哈希算法&#xff0c;它可能会发送大量的请求&#xff0c;导致产生严重的哈希碰撞。然后不停的访问这些key就能显著的影响服务器的性能&#xff0c;这样就形成了一次拒绝服务攻击&#xff08;DoS&#xff09;。JDK 8中从O(n)到O(logn)的飞跃&#xff0c;可以有效地防止类似的攻击&#xff0c;同时也让HashMap性能的可预测性稍微增强了一些 从上面可看出&#xff1a;在扩容resize&#xff08;&#xff09;过程中&#xff0c;在将旧数组上的数据 转移到 新数组上时&#xff0c;转移数据操作 &#61; 按旧链表的正序遍历链表、在新链表的头部依次插入&#xff0c;即在转移数据、扩容后&#xff0c;容易出现链表逆序的情况 设重新计算存储位置后不变&#xff0c;即扩容前 &#61; 1->2->3&#xff0c;扩容后 &#61; 3->2->1 此时若并发执行 put 操作&#xff0c;一旦出现扩容情况&#xff0c;则 容易出现 环形链表&#xff0c;从而在获取数据、遍历链表时 形成死循环&#xff08;Infinite Loop&#xff09;&#xff0c;即死锁 单线程情况下&#xff0c;rehash无问题 这里假设有两个线程同时执行了put操作并引发了rehash&#xff0c;执行了transfer方法&#xff0c;并假设线程一进入transfer方法并执行完next &#61; e.next后&#xff0c;因为线程调度所分配时间片用完而“暂停”&#xff0c;此时线程二完成了transfer方法的执行。此时状态如下。 接着线程1被唤醒&#xff0c;继续执行第一轮循环的剩余部分 结果如下图所示 接着执行下一轮循环&#xff0c;结果状态图如下所示 继续下一轮循环&#xff0c;结果状态图如下所示 此时循环链表形成&#xff0c;并且key(11)无法加入到线程1的新数组。在下一次访问该链表时会出现死循环。 在使用迭代器的过程中如果HashMap被修改&#xff0c;那么ConcurrentModificationException将被抛出&#xff0c;也即Fast-fail策略。 当HashMap的iterator()方法被调用时&#xff0c;会构造并返回一个新的EntryIterator对象&#xff0c;并将EntryIterator的expectedModCount设置为HashMap的modCount&#xff08;该变量记录了HashMap被修改的次数&#xff09;。 在通过该Iterator的next方法访问下一个Entry时&#xff0c;它会先检查自己的expectedModCount与HashMap的modCount是否相等&#xff0c;如果不相等&#xff0c;说明HashMap被修改&#xff0c;直接抛出ConcurrentModificationException。该Iterator的remove方法也会做类似的检查。该异常的抛出意在提醒用户及早意识到线程安全问题。 单线程条件下&#xff0c;为避免出现ConcurrentModificationException&#xff0c;需要保证只通过HashMap本身或者只通过Iterator去修改数据&#xff0c;不能在Iterator使用结束之前使用HashMap本身的方法修改数据。因为通过Iterator删除数据时&#xff0c;HashMap的modCount和Iterator的expectedModCount都会自增&#xff0c;不影响二者的相等性。如果是增加数据&#xff0c;只能通过HashMap本身的方法完成&#xff0c;此时如果要继续遍历数据&#xff0c;需要重新调用iterator()方法从而重新构造出一个新的Iterator&#xff0c;使得新Iterator的expectedModCount与更新后的HashMap的modCount相等。 多线程条件下&#xff0c;可使用Collections.synchronizedMap方法构造出一个同步Map&#xff0c;或者直接使用线程安全的ConcurrentHashMap。 - END -/*** 该函数有2种使用情况&#xff1a;1.初始化哈希表 2.当前数组容量过小&#xff0c;需扩容*/
final Node[] resize() {Node[] oldTab &#61; table;int oldCap &#61; (oldTab &#61;&#61; null) ? 0 : oldTab.length;int oldThr &#61; threshold;int newCap, newThr &#61; 0;// 针对情况2&#xff1a;若扩容前的数组容量超过最大值&#xff0c;则不再扩充if (oldCap > 0) {if (oldCap >&#61; MAXIMUM_CAPACITY) {threshold &#61; Integer.MAX_VALUE;return oldTab;}// 针对情况2&#xff1a;若无超过最大值&#xff0c;就扩充为原来的2倍else if ((newCap &#61; oldCap <<1) 4.7 remove方法
final Node removeNode(int hash, Object key, Object value,boolean matchValue, boolean movable) {Node[] tab; Node p; int n, index;if ((tab &#61; table) !&#61; null && (n &#61; tab.length) > 0 &&(p &#61; tab[index &#61; (n - 1) & hash]) !&#61; null) {Node node &#61; null, e; K k; V v;if (p.hash &#61;&#61; hash &&((k &#61; p.key) &#61;&#61; key || (key !&#61; null && key.equals(k))))// index 元素只有一个元素node &#61; p;else if ((e &#61; p.next) !&#61; null) {if (p instanceof TreeNode)// index处是一个红黑树node &#61; ((TreeNode)p).getTreeNode(hash, key);else {// index处是一个链表&#xff0c;遍历链表返回nodedo {if (e.hash &#61;&#61; hash &&((k &#61; e.key) &#61;&#61; key ||(key !&#61; null && key.equals(k)))) {node &#61; e;break;}p &#61; e;} while ((e &#61; e.next) !&#61; null);}}// 分不同情形删除节点if (node !&#61; null && (!matchValue || (v &#61; node.value) &#61;&#61; value ||(value !&#61; null && value.equals(v)))) {if (node instanceof TreeNode)((TreeNode)node).removeTreeNode(this, tab, movable);else if (node &#61;&#61; p)tab[index] &#61; node.next;elsep.next &#61; node.next;&#43;&#43;modCount;--size;afterNodeRemoval(node);return node;}}return null;}
4.8 get
/*** 函数原型* 作用&#xff1a;根据键key&#xff0c;向HashMap获取对应的值*/ map.get(key)&#xff1b;/*** 源码分析*/ public V get(Object key) {Node e;// 1\. 计算需获取数据的hash值// 2\. 通过getNode&#xff08;&#xff09;获取所查询的数据 ->>分析1// 3\. 获取后&#xff0c;判断数据是否为空return (e &#61; getNode(hash(key), key)) &#61;&#61; null ? null : e.value;
}
/*** 分析1&#xff1a;getNode(hash(key), key))*/
final Node getNode(int hash, Object key) {Node[] tab; Node first, e; int n; K k;// 1\. 计算存放在数组table中的位置if ((tab &#61; table) !&#61; null && (n &#61; tab.length) > 0 &&(first &#61; tab[(n - 1) & hash]) !&#61; null) {// 4\. 通过该函数&#xff0c;依次在数组、红黑树、链表中查找&#xff08;通过equals&#xff08;&#xff09;判断&#xff09;// a. 先在数组中找&#xff0c;若存在&#xff0c;则直接返回if (first.hash &#61;&#61; hash && // always check first node((k &#61; first.key) &#61;&#61; key || (key !&#61; null && key.equals(k))))return first;// b. 若数组中没有&#xff0c;则到红黑树中寻找if ((e &#61; first.next) !&#61; null) {// 在树中getif (first instanceof TreeNode)return ((TreeNode)first).getTreeNode(hash, key);// c. 若红黑树中也没有&#xff0c;则通过遍历&#xff0c;到链表中寻找do {if (e.hash &#61;&#61; hash &&((k &#61; e.key) &#61;&#61; key || (key !&#61; null && key.equals(k))))return e;} while ((e &#61; e.next) !&#61; null);}}return null;
}/*** 源码分析&#xff1a;resize(2 * table.length)* 作用&#xff1a;当容量不足时&#xff08;容量 > 阈值&#xff09;&#xff0c;则扩容&#xff08;扩到2倍&#xff09;*/ void resize(int newCapacity) {// 1\. 保存旧数组&#xff08;old table&#xff09;Entry[] oldTable &#61; table;// 2\. 保存旧容量&#xff08;old capacity &#xff09;&#xff0c;即数组长度int oldCapacity &#61; oldTable.length;// 3\. 若旧容量已经是系统默认最大容量了&#xff0c;那么将阈值设置成整型的最大值&#xff0c;退出if (oldCapacity &#61;&#61; MAXIMUM_CAPACITY) {threshold &#61; Integer.MAX_VALUE;return;}// 4\. 根据新容量&#xff08;2倍容量&#xff09;新建1个数组&#xff0c;即新tableEntry[] newTable &#61; new Entry[newCapacity];// 5\. &#xff08;重点分析&#xff09;将旧数组上的数据&#xff08;键值对&#xff09;转移到新table中&#xff0c;从而完成扩容 ->>分析1.1transfer(newTable);// 6\. 新数组table引用到HashMap的table属性上table &#61; newTable;// 7\. 重新设置阈值threshold &#61; (int)(newCapacity * loadFactor);
}/*** 分析1.1&#xff1a;transfer(newTable);* 作用&#xff1a;将旧数组上的数据&#xff08;键值对&#xff09;转移到新table中&#xff0c;从而完成扩容* 过程&#xff1a;按旧链表的正序遍历链表、在新链表的头部依次插入*/
void transfer(Entry[] newTable) {// 1\. src引用了旧数组Entry[] src &#61; table;// 2\. 获取新数组的大小 &#61; 获取新容量大小int newCapacity &#61; newTable.length;// 3\. 通过遍历 旧数组&#xff0c;将旧数组上的数据&#xff08;键值对&#xff09;转移到新数组中for (int j &#61; 0; j 单线程rehash
多线程并发下的rehash
e.next &#61; newTable[1] &#61; null
newTable[1] &#61; e &#61; key(5)
e &#61; next &#61; key(9)Fast-fail
产生原因
HashIterator() {expectedModCount &#61; modCount;if (size > 0) { // advance to first entryEntry[] t &#61; table;while (index
线程安全解决方案
最近整理一份面试资料《Java技术栈学习手册》&#xff0c;覆盖了Java技术、面试题精选、Spring全家桶、Nginx、SSM、微服务、数据库、数据结构、架构等等。
获取方式&#xff1a;点“ 在看&#xff0c;关注公众号 Java后端 并回复 777 领取&#xff0c;更多内容陆续奉上。
推荐阅读
1. 每日一题之 ZooKeeper
2. 每日一题之 Redis
3. 每日一题之 MySQL4. 每日一题之 JVM-015. 每日一题之 JVM-02
6.每日一题之 JVM-037.
每日一题之线程
喜欢文章&#xff0c;点个在看