1.HashMap源码解读
学过数据结构的都知道， Hash表是一种动态查找表， 理想情况下不经过任何比较就能找到对应的元素(理想很美好，现实很残酷)。一个具有良好Hash函数的Hash表， 查找速度是很快的。HashMap的底层就是基于Hash表实现的。下图就是一个Hash表结构。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q7ev5VVI-1589093870697)(D:\笔记图片集\watermark,g_7,image_d2F0ZXIvYmFpa2U4MA==,xp_5,yp_5)]
当然HashMap的Hash表不是这么简单。在Java1.8，HashMap的Hash表是数组+链表，达到一定的阈值就会变成数组+红黑树。
1.1HashMap内部的常量
//常量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认初始化容量
static final int MAXIMUM_CAPACITY = 1 << 30; //最大容量(最大表长)
static final float DEFAULT_LOAD_FACTOR = 0.75f; //默认的装载因子
static final int TREEIFY_THRESHOLD = 8; //阈值
static final int UNTREEIFY_THRESHOLD = 6;//非红黑树的阈值
static final int MIN_TREEIFY_CAPACITY = 64;//树的最小容量
为什么负载因子默认是0.75？按照官方给出的解释是，当负载因子为0.75时候，
Entry单链表的长度几乎不可能超过8(到达8的概率是0.00000006)，作用就是让Entry单链表的长度尽量小，让HashMap的查询效率尽可能高。
由于当HashMap的大小(即size)大于初始容量(capacity)时候，HashMap就会扩大一倍，由于很多时候并不需要扩大这么多，所以当我们知道我们的数据的大小的时候，就可以在HashMap初始化的时候指定容量(数组大小)。
需要注意的是，我们指定的容量必须是2的幂次方，即使我们传入的容量不是2的幂次方，源码中也会将容量转成2的幂次方，比如我们传入的是5，最终的容量是8。
//将一个cap 转化为2的指数的算法
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
为什么容量一定要是2的幂次方？因为HashMap是数组+单链表的结构，我们希望元素的存放的更均匀，最理想的状态是每个Entry中只存放一个元素，这样在查询的时候效率最高。那怎么才能均匀的存放呢？我们首先想到的是取模运算 哈希地址%容量大小，SUN的大师们的想法和我们的也一样，只不过他们使用位运算来实现这个运算(位运算效率高)，为了使位运算和取模运算结果一样，即hash & (capacity - 1) == hash % capacity，容量(Capacity)的大小就必须为2的幂次方。
对于当capacity为2指数时，hash & (capacity - 1) == hash % capacity的解释
因为
c=a%b等价于a=k*b+c。当b为2的指数时(以8为例)
b=8
b的二进制
00001000k*b 就是1前面几位：
xxxx1000， x为0或1所以余数c 就是1后面几位：
00000xxx， x为0或1。
1.2.成员变量
transient Node<K,V>[] table;//内部的Hash表
transient Set<Map.Entry<K,V>> entrySet;// 键值对的集合
transient int size;//HashMap大小， 即已存储键值对的个数
transient int modCount;//修改次数的统计
int threshold; //阈值————hash表扩容的衡量 =loadFactor*表容量
final float loadFactor;//装载因子
1.3. 构造方法
构造方法没有构造表(造表是在扩容函数中造的)， 基本上就是设置变量threshold、loadFactor， 以便于扩容机制，进行扩容(或构造表)。
//构造方法①
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;
this.threshold = tableSizeFor(initialCapacity);
}
//构造方法②
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//构造方法③
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // 无参的构造方法默认装载因子为0.75f
}
//构造方法④
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
1.4. put方法
/*
压入键值对方法
内部封装了putVal方法
*/
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;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果表头为空则， 则通过传入的键值对， new一个头结点。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//如果头不为空
else {
Node<K,V> e; K k;
//与第一个节点进行比较， 如果该结点的键与传入的key相等， 则将p赋值给e
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 {
//对于链表进行遍历， 直到找找到 键与键的哈希码相等的节点， 或者遍历到结尾。
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;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果e不为空， 说明有需要覆盖的节点
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;//返回旧的value
}
}
//每插入一个新结点， modCount就会加一
++modCount;
//元素个数与阈值进行比较， 判断是否启动扩容机制。
if (++size > threshold)
resize();
afterNodeInsertion(evict);//LinkedhashMap的重写使用
return null;// 返回一个空值
}
从上面的代码可以看出， put键值对时， 对键的判重的机制是由
p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k)))条件来确定(即先判断hash值是否相等然后在比较key)。
其中hash是由以下函数得到
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
由此看来，要修改判重机制我们可以重写key类的hashCode()方法和equals()方法。
1.5.get方法
/*
获取对应key的value值方法。
内部调用了 getNode方法。
如果 getNode方法返回为空， 则该方法返回为空
否则返回获取到的Node e的value值
*/
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/*
获取节点的方法。
参数：键的hashCode 和键
总体过程就是：
①先判断hash表不空和表的容量不为0，并且通过 (n - 1) & hash获取key在表中的hash地址，该地址的第一个元素不为空。 如果满足条件继续判断。 否则返回null
②通过first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k)))等条件将第一个节点的key与我们传入的k是否相等。 如果相等返回第一个节点
③判断下一个节点（即第二个节点）不为空， 则继续。否则返回null
④如果是基于树的则在树中寻找，
如果不是基于树的则在链表中循环比较，直到找到相等的key或者遍历到结尾。
*/
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))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
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;
}
1.6. resize()方法， 扩容方法
JDK1.7中，resize时，index取得时，全部采用重新hash的方式进行了。JDK1.8对这个进行了改善。
以前扩容时确定新的hash地址index时要重新通过e.hash&(newCap-1)(即对newCap取余)获得， 而1.8却不一样。
它先根据e.hash&oldCap判断将这当前这个链上的元素分为两类(这里只指数组+链表的情况)。
-
一类结果为0。这类在新表的hash地址不变
以
oldCap=8为例:其二进制
00001000,newCap=16二进制00010000e.hash&oldCap==0则e.hash的二进制形式是xxxx0xxx，x为0或1。e.hash对于oldCap和newCap的余数都是
00000xxx。 -
另一类结果为oldCap。这类在新表的hash地址为
旧表hash地址+oldCap以
oldCap=8为例:其二进制
00001000,newCap=16二进制00010000e.hash&oldCap==oldCap则e.hash的二进制形式是xxxx1xxx，x为0或1。e.hash对于oldCap的余数都是
00000xxx。对于newCap的余数是
00001xxx, 就等于00001000+00000xxx（即旧hash地址+oldCap）。
/*
重置大小
*/
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//如果表为空则旧容量为0， 否则就是表的长度。
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;
}
//新表的容量变为
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。 构造方法传入的初始化容量放置在threshold中。 该方法针对的是构造时代带有初始容量参数的。
newCap = oldThr;
else { // zero initial threshold signifies using defaults。 该判断主要针对的是构造时，无初始化容量参数的。
newCap = 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) {
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) {//这种情况 ， 表示 hash < oldCap。 所以它的在新表的哈希地址是不变的 —————— 哈希表的哈希函数是： hash&[cap-1], 其中hash=hash(key)
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;
}
1.7. containKey()方法
该方法是通过getNode获取对应key的节点， 判断节点是否存在来判断是否包含对应的key值
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
1.8. containValue() 方法
由代码可知查找一个HashMap是否包含某个value值是遍历整个hash表， 所以查找速度很慢
/*
查找是否包含传入的value值。
使用两层for循环遍历一整个表， 所以找value时很慢。
*/
public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
if ((tab = table) != null && size > 0) {
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
return false;
}
1.9.remove()方法
找到所在hash地址然后再找key所对应的节点进行删除。
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
1.10. keySet()、values()、entrySet() 等返回集合的方法
/*********返回集合的这几种方法， 内部new一个新的集合，但是这几个集合并没有存值，而是添加了一些对hash表进行处理的方法************/
public Set<K> keySet() {
Set<K> ks = keySet;
if (ks == null) {
ks = new KeySet();
keySet = ks;
}
return ks;
}
final class KeySet extends AbstractSet<K> {
public final int size() { return size; }
public final void clear() { HashMap.this.clear(); }
public final Iterator<K> iterator() { return new KeyIterator(); }
public final boolean contains(Object o) { return containsKey(o); }
public final boolean remove(Object key) {
return removeNode(hash(key), key, null, false, true) != null;
}
public final Spliterator<K> spliterator() {
return new KeySpliterator<>(HashMap.this, 0, -1, 0, 0);
}
public final void forEach(Consumer<? super K> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
//循环遍历hash表
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e.key);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
public Collection<V> values() {
Collection<V> vs = values;
if (vs == null) {
vs = new Values();
values = vs;
}
return vs;
}
final class Values extends AbstractCollection<V> {
public final int size() { return size; }
public final void clear() { HashMap.this.clear(); }
public final Iterator<V> iterator() { return new ValueIterator(); }
public final boolean contains(Object o) { return containsValue(o); }
public final Spliterator<V> spliterator() {
return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
}
public final void forEach(Consumer<? super V> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
//循环遍历hash表
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e.value);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
}
final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public final int size() { return size; }
public final void clear() { HashMap.this.clear(); }
public final Iterator<Map.Entry<K,V>> iterator() {
return new EntryIterator();
}
public final boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
Object key = e.getKey();
Node<K,V> candidate = getNode(hash(key), key);
return candidate != null && candidate.equals(e);
}
public final boolean remove(Object o) {
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
Object key = e.getKey();
Object value = e.getValue();
return removeNode(hash(key), key, value, true, true) != null;
}
return false;
}
public final Spliterator<Map.Entry<K,V>> spliterator() {
return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
}
public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
//循环遍历hash表
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
参考写的很不错， 可以看一下参考
参考
- java源码
- java集合之HashMap的扩容resize
- （1）美团面试题：Hashmap的结构，1.7和1.8有哪些区别，史上最深入的分析
- https://blog.csdn.net/xueba8/article/details/88352244
扫一扫
3189
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
