HashMap主要实现了Map接口,本文主要介绍HashMap的几个方法,如果涉及到源码,都是基于jdk11的
行文结构
目录
1哈希表和链表
介绍几个概念:
数组:
采用一段连续的存储单元来存储数据.对给定下标的查找,时间复杂度为O(1),对给定值的查找,时间复杂度为O(n),n为数组长度,因为要遍历整个数组,依次比较给定值和数组中的各元素,数组实现查询和修改快,实现增加和删除慢,比如除了在尾部增加和删除,在其他地方的增加和删除,其他元素都会响应移动,所以慢点
线性链表:
链表可以看成是一根断了的自行车链条,链表上的每个节点的存储地址是不连续的,链表的增加和删除操作快,时间复杂度为O(1),而查询慢,时间复杂度为O(n),原因是增加和删除的时候,只需要将新节点加入到两个链表的节点之间,或者将旧节点从两个链表节点之间删除,将两个链表的指向关系重新写下就好了
二叉树
二叉树有多种结构,比如平衡二叉树,对当前节点来说,节点左边的元素总比节点右边的元素要大,对其插入,查找,删除操作的平均时间复杂度都是O(logn)
哈希表
哈希表` 是以一种容易找到它们的方式存储的项的集合。哈希表的每个位置，通常称为一个槽，可以容纳一个项，并且由从 0 开始的整数值命名。例如，我们有一个名为 0 的槽，名为 1 的槽，名为 2 的槽，以上。最初，哈希表不包含项，因此每个槽都为空。我们可以通过使用列表来实现一个哈希表，每个元素初始化为`null`.
hash的方式是通过散列的方式将元素均匀分布到hash表中.即对给定关键字比如key值经过hash函数计算后,得到它要存储的地址
给定项的集合，将每个项映射到唯一槽的散列函数被称为完美散列函数。如果我们知道项和集合将永远不会改变，那么可以构造一个完美的散列函数。不幸的是，给定任意的项集合，没有系统的方法来构建完美的散列函数。幸运的是，我们不需要散列函数是完美的，仍然可以提高性能。总是具有完美散列函数的一种方式是增加散列表的大小，使得可以容纳项范围中的每个可能值。这保证每个项将具有唯一的槽。虽然这对于小数目的项是实用的，但是当可能项的数目大时是不可行的。即便hash表中的位置没有占满,散列函数还是可能计算出两个不同的元素的hash值相同的,
每个元素要想放入到哈希表,首先要通过hash函数计算它的hash值,当两个项散列到同一个槽时，我们必须有一个系统的方法将第二个项放在散列表中。这个过程称为冲突解决。
在不考虑哈希冲突的情况下,添加,删除,查找等操作仅需要一次计算hash表中位置,即可定位完成操作,时间复杂度为O(1)
解决冲突的一种方法是查找散列表，尝试查找到另一个空槽以保存导致冲突的项。一个简单的方法是从原始哈希值位置开始，然后以顺序方式移动槽，直到遇到第一个空槽。注意，我们可能需要回到第一个槽（循环）以查找整个散列表。这种冲突解决过程被称为开放寻址，因为它试图在散列表中找到下一个空槽或地址。通过系统地一次访问每个槽，我们执行称为线性探测的开放寻址技术。
然而,在HashMap中,解决哈希冲突采用的是数组+链表/红黑树的方式,即如果hash值相同,那么对应hash表的那个槽处成为一个链表,往链表上增加元素.,那位可能会说,既然hash表上可以有链表,链表的长度是无限的,初始化HashMap后,不需要再扩容了,理论上初始化的HashMap的哈希表长度是16,是可以存储无限多元素,实际上如果链表/红黑树过大,查找,增加,删除等操作需要遍历链表/红黑树的话,效率就变低了,所以容量的使用达到一定量了,还是扩容吧
画个图,说明下HashMap的存储样例
2HashMap的实现原理 (源码角度)
开始前,先说明几个名词
数组结构的每一个槽称为桶
桶中存放的每一个数据称为bin
size,Map中存放的键值对个数,包括数组中的元素和每个桶中(包括链表或者红黑树中)元素的总和
capacity,HashMap中桶的数量
loadFactor,填充因子,也叫装载因子,计算HashMap中实时装载因子的公式为size/capacity(待验证)
threshold: 当HashMap的size大于threshold时会执行resize扩容操作
2.1先看一些成员变量,即属性:
* The default initial capacity - MUST be a power of two.
//默认的初始化容量即数组长度必须是2的多少次幂,在这里3效率要高是1左移4,即16,左移比直接乘效率高
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量1*(2^30)
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的填充因子是0.75,即达到现有容量的0.75倍即开始扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 这是一个阈值，当桶(bucket)上的链表元素个数大于这个值时会转成红黑树，put方法的代码里有用到
static final int TREEIFY_THRESHOLD = 8;
// 扩容时,如果一个桶中的元素个数小于这个值,转化为链表
static final int UNTREEIFY_THRESHOLD = 6;
// 树形化和扩容的选择阈值,只有数组的大小超过这个阈值，单个桶才可以被转换成树而不是链表（
数组长度小于这个值时，应该使用resize扩容,增加表的长度而不是增加桶的深度）
//这个值最少是TREEIFY_THRESHOLD的4倍，以避免扩容和树化之间产生冲突
static final int MIN_TREEIFY_CAPACITY = 64;
//数组的长度,即表的长度
transient Node<k,v>[] table;
transient Set<map.entry<k,v>> entrySet;
// 存放元素的个数，注意这个不等于数组的长度。
transient int size;
// 每次扩容和更改map结构的计数器
transient int modCount;
// 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
int threshold;
// 填充因子
final float loadFactor;2.2构造方法:
构造方法,初始化了一些属性
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
//上述三个构造方法都调用下面这个构造方法
//下面这个构造方法大部分都在判断传入的值是否合法,看最后一行就行了
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;
//此时table还未分配到内存，threshold就是将要分配的数组大小
this.threshold = tableSizeFor(initialCapacity);
}
//这个函数的返回值是2的n次方,且返回值大于等于cap(构造方法中传入的容量)
static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}构造方法保证初始化的数组长度比传入值大且最接近2的n次幂的一个数,比如传进去100,构造的数组长度为128
HashMap的实现原理,
为什么hashMap的长度一定要是2的幂?
我们知道往HashMap中添加一个元素时1调用元素自身的hashCode方法,获取hashCode值,尽量将值散列开,再调用hash函数,
static final int hash(Object key) {
int h;
//使用hashCode的值与(hashCode的值无符号右移16位）做异或操作
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//hashCode是类继承自Object的一个重写的方法,返回的值尽量散列开
//(h>>>16)为了避免hash碰撞(hash collisons)将高位分散到低位上了，这是综合考虑了速度，性能等各方面因素之后做出的hash里面做了一件事,判断key是否为空,为空返回hash值为0,不为空返回hashCode值与右移16位的hashCode值的异或值,目的还是将hash值均匀散列,下一步是要查找索引,用到了hash值,看下一行代码,
if ((p = tab[i = (n - 1) & hash]) == null) //计算索引,判断索引处的桶是否为空
计算索引的方法为i=(n-1)&hash我们知道n为hashMap的容量即桶的数量,如果n为2的幂,(n-1)&hash保证获取的索引值在数组范围内,如下图,hashCode值为一个大数值,经过hash运算后,再与n-1位与运算,得到的索引就在数组长度范围内
如果多个key计算出来的索引值一样,那就都放入同一个位置的桶中,插入到链表或者红黑树中
查找也是相似流程,定位到索引后,如果bucket的节点的key不是我们需要的（也就是发生了冲突），则通过keys.equals()在链中比较,时间复杂度为O(1)+O(n)。jdk8之后改为了利用红黑树替换链表，这样复杂度就变成了O(1)+O(logn)了
3HashMap的put,get方法
put:
1、对key的hashCode()做hash，然后再计算index; 如果没碰撞直接放到桶bucket里；如果碰撞了，以链表的形式存在同buckets里,如果索引处的桶的链表长度大于阈值,(默认为8),就将链表转成红黑树,(转成红黑树是在数组长度大于64时才能转),如果节点已经存在同一个key值就替换old value(保证key的唯一性)；如果桶bucket的个数超过(load factor * current capacity)，就扩容。
put方法源码:
public V put(K key, V value) {
// 对key的hashCode()做hash运算
return putVal(hash(key), key, value, false, true);
}
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)
//key的hash值与(数组table的长度-1)进行相与得出在数组中的位置(与取余一样,但这样效率高)，如果为空说明数组上这个位置没被占用，创建一个Node内部类节点赋值给数组。
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))))
//判断原数组存储的是否同一个key元素，如果是,通过变量e记录下该位置，在下面把该元素的value替换为新值
e = p;
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的元素，说明该链表没有原值,new一个node添加到链表
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//如果遍历的链表长度大于=8,尝试转换为树形结构
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
//如果遍历过程中找到相同key的元素，e记录位置后跳出循环
break;
p = e;
}
}
if (e != null) { // existing mapping for key
如果e不为空说明找到原来的key，把原来node上的值赋予新值
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
添加一个元素后size加1，如果目前存在元素数量大于threshold=capacity*loadFactor后进行扩容,
resize();
afterNodeInsertion(evict);
return null;
}
2 get方法:
调用key的hashCode()方法计算其hashcode值,再对key的hashCode值做hash运算，再计算index;如果该 index 对应的桶没有元素，则直接返回 null；index对应的桶中有元素,判断桶中第一个节点的key是否跟get(key)的key值相同,相同则返回此位置的元素
不同,则对该桶下的树结构或者链表结构查找,找到则返回元素的value值,找不到则返回null
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}getNode方法的源码:
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))))
// table数组的这个桶的第一个节点正好是取的值
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
//如果是树形结构通过树形方法遍历取node
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;
}4HashMap的扩容
当HashMap中的元素个数超过数组大小*负载因子时，就会进行数组扩容，loadFactor的默认值为0.75.默认情况下，数组大小为16，那么当HashMap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。
扩容时对原有元素的处理,桶中没有元素的,不处理,桶中只有一个元素节点,重新计算index(计算方式为hash&(newCap-1)),桶中有多个节点,因为capcity总是2的幂,扩容变成原来的2倍,从二进制来看,只是向左移动一位,此时不会重新计算所有index,而是看看原来的hash值新增的那个bit位是0还是1,(因为容量扩大了一倍，因此影响结果的是hash之前没有参与运算的最右侧位值，通过 hash & oldCap 便能得到),0的话索引没变,1的话索引变为"原索引+oldCap".
resize函数源码:
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//如果旧数组为空,旧表容量为0,旧表不为空的话,旧表容量为旧数组的长度
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) { //如果旧表容量大于0
if (oldCap >= MAXIMUM_CAPACITY) {
判断旧表容量是否为最大容量,如果是最大容量,不扩容
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//旧表容量*2以后还没达到最大容量,加倍
newThr = oldThr << 1; // double threshold
} //如果旧表容量等于0
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr; 使用默认设置添加容量为16
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;
if (oldTab != null) { //如果旧的数组不为空，要把就的数组的值遍历放入到新的数组表
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) { //如果旧表第j个位置上的桶不为空
oldTab[j] = null;
if (e.next == null)
//如果旧数组这个位置存储的桶里是单个node对象没有链表，
//直接把该node的hash值和新的table-1进行相与取得新的存储位置
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) {
//(e.hash & oldCap)判断mask范围在高位多1bit是否有值，如果有值新位置为（原索引+oldCap）否则为原索引位置
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;
}
resize后新索引位置图解:根据源码分析
if ((e = oldTab[j]) != null) { //如果旧表第j个位置上的桶不为空
oldTab[j] = null;
if (e.next == null)
//如果旧数组这个位置存储的桶里是单个node对象没有链表，
//直接把该node的hash值和新的table-1进行相与取得新的存储位置
newTab[e.hash & (newCap - 1)] = e;上面几行代码(resize方法里的)说了一件事,如果旧数组中莫个桶中只有一个元素,那这个元素在新数组中的索引值为e.hash&(newCap-1),
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
//(e.hash & oldCap)判断mask范围在高位多1bit是否有值，如果有值新位置为（原索引+oldCap）否则为原索引位置
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;//添加到（旧索引+旧表长度）位置
}
}上面几行代码(resize方法里的)做了一件事,处理桶中非单个元素的事情,if ((e.hash & oldCap) == 0) 这行计算的是e.hash&(oldCap),而不是之前咱们计算索引的hash&(n-1),(注:n和oldCap都表示旧数组的长度,把高位屏蔽),这行计算出来的就是hash值与原数组长度相与的结果的高位,咱们知道地位的结果不会变,高位为1,重新计算出来的索引值比旧数组中的索引值多了OldCap,如果为0,计算出来在新数组的索引值也不会变的
树化函数:
putVal函数中
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
//如果一个桶中的元素个数大于8,会调用此函数,判断能否将链表转换为红黑树,如不能树化则进行resize扩容操作
final void treeifyBin(Node<K, V>[] tab, int hash) {
// e是hash值和数组长度计算后，得到链表的首节点,
int n, index;
Node<K, V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
// 如果元素数组长度已经大于等于了 MIN_TREEIFY_CAPACITY，这个桶bucket就要转换成树形结构
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K, V> hd = null, tl = null;
do {
TreeNode<K, V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
参考:https://blog.csdn.net/dhfzhishi/article/details/78173191
https://www.jianshu.com/p/f2361d06da82
https://blog.csdn.net/weixin_39220472/article/details/80459364
|
| Options : History : Feedback : Donate | Close |
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
