目录
hashmap数据结构
map中存储的是key,value键值对。众所周知，hashmap是采用的 数组 + 链表 + 红黑树 的数据结构存储数据的。下方方形表示的是数组，初始化状态长度是16。数组中每个元素我们这里称之为桶，桶存储的是key的hash值，每个桶后面挂载着链表，链表中存储的是具体的数据value。
Hash表属性
//默认table大小，是16，左移4位
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//table最大长度
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;
//整个hash表元素超过64变成树
static final int MIN_TREEIFY_CAPACITY = 64;
//hash表建立
transient Node<K,V>[] table;
//将数据转换成set的另一种存储形式，这个变量主要用于迭代功能。
transient Set<Map.Entry<K,V>> entrySet;
//hash表中元素个数
transient int size;
//当前hash表结构修改次数
transient int modCount;
//当hash表元素超过阈值，触发扩容
int threshold;
//默认因子=数组长度*负载因子值
final float loadFactor;构造函数
第一个：空参构造方法，使用默认的负载因子为0.75；
第二个：设置初始容量并使用默认加载因子；
第三个：设置容量和加载因子，第二个构造方法最终还是调用了第三个构造方法；
第四个：将一个Map转换为HashMap。
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0) //长度小于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);
}putMapEntries 方法
putMapEntries函数会被HashMap的拷贝构造函数public HashMap(Map<? extends K, ? extends V> m)或者Map接口的putAll函数（被HashMap给实现了）调用到。该函数由于是默认的包访问权限，所以一般情况下用户无法调用。
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size(); //获取该map的实际长度
if (s > 0) {
if (table == null) { //判断table是否初始化
float ft = ((float)s / loadFactor) + 1.0F; //求出需要的容量
int t = ((ft < (float)MAXIMUM_CAPACITY) ? //判断该容量大小是否超出上限
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold) //对临界值进行初始化
threshold = tableSizeFor(t);
}
else if (s > threshold) //如果table已经初始化，则进行扩容操作
resize();
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
//遍历，把map中的数据转到hashMap中
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}HashMap 5个主要方法
getNode方法
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//tab :引用当前 hashMap 的散列表
//first:桶位中的头元素
//e :临时 node 元素
//n : tabLe 数组长度
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash &&
//第一种情况: 定位出来的桶位元素 即为咱们要get的数据
((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;
}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;
//tab :引用当前 hashMap 的散列表
//p :表示当前散列表的元素
//n :表示散列表数组的长度
//i :表示路由寻址结果
if ((tab = table) == null || (n = tab.length) == 0)
//延迟初始化逻辑,第一次调用 putvaL 时会初始化 hashMap 对象中的最耗费内存的散列表
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//最简单的一种情况:寻址找到的桶位刚好是 null ,
//这个时候,直接将当前 k-v => node 扔进去就可以了
tab[i] = newNode(hash, key, value, null);
else {
//不为null的话,找到了一个与当前要插入的key-value一致的key的元素
Node<K,V> e; K k; //k :表示临时的一个 key
if (p.hash == hash && //表示桶位中的该元素,与你当前插入的元素的
//key 完全一致,表示后线需要进行替换操作
((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 { //链表的情况,而且链表的头元素与我们要插入的ke不一致
for (int binCount = 0; ; ++binCount) {
//条件成立的话,说明选代到最后一个元素了,也没找到
//一个与你要插入的 key 一致的 node
说明需要加入到当前链表的末尾
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//条件成立的话，说明当前链表的长度达到树化的标准
if (binCount >= TREEIFY_THRESHOLD - 1) //树化操作
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
//条件成立的话,说明找到了相同 key 的 node 元素,需要进行替换操作
break;
p = e;
}
}
if (e != null) { //e 不等于 nulL .条件成立说明,找到了一个与你插入元素
//key 完全一致的数据,需要进行替换
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount; //modCount :表示散列表结构被修改的次数,替换Node元素的vatue不计数
if (++size > threshold) //插入新元索, size 自增。
//如果自增后的值大于扩容阈值,则触发扩容
resize();
afterNodeInsertion(evict);
return null;
}1、根据key计算出在数组中存储的下标
2、根据使用的大小，判断是否需要扩容。
3、根据数组下标判断是否当前下标已存储数据，如果没有则直接插入。
4、如果存储了则存在哈希冲突，判断当前entry的key是否相等，如果相等则替换，
否则判断下一个节点是否为空，为空则直接插入，否则取下一节点重复上述步骤。
5、判断链表长度是否大于8当达到8时转换为红黑树。
resize方法
为什么需要扩容？为了解决哈希冲突导致的链化影响在询效率的问题。扩容会緩解该问题。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//oldTab: 引用扩容前的哈希表
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//oldCap:表示扩容之前table数组的长度
int oldThr = threshold;
//oldThr: 表示扩容之前的扩容阅值，触发本次扩容的阈值
int newCap, newThr = 0;
//newCap:扩容之后table数组的大小
//newThr:扩容之后，下 次再次触发扩容的条件
if (oldCap > 0) { //条件如果成立说明 hashMap 中的散列表已经初始化过了,
//这是一次正常扩容
if (oldCap >= MAXIMUM_CAPACITY) { //扩容之前的 table 数组大小已经达到最大阈
//值后,则不扩容,且设置扩容条件为 int 最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
/*oldCap左移位实现数值翻倍，并且赋值给newCap, newCap 小于数组最大值限制且扩容之前
的阙值>= 16; 这种情况下，则下次扩容的阅值等于当前测值翻倍*/
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) /*oldCap == 0,说明 hashMap 中的散列表是nul1
1.new HashMap ( initCap , LoadF actor );
2.new HashMap ( initCap )
3.new HashMap ( map );且这个 map 有数据*/
newCap = oldThr;
else { //oldCap=0, oldThr== 0
//new HashMap ();
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) { //newThr 为零时通过 tnewCap 和
//LoadFactor 计算出一个 newThr
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) { //说明, hashMap 本次扩容之前, table 不为 null
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e; //当前node节点
if ((e = oldTab[j]) != null) { //说明当前桶位中有数据,但是数据具体
//是单个数据,还是链表还是红黑树并不知道
oldTab[j] = null; //方便 JVM GC时回收内存
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 { //第三种情况:桶位已经形成链表
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;
}总结一下上面的逻辑就是：
1、对数组进行扩容，
2、扩容后重新计算hashCode也就是key的下标，将原数据塞到新扩容后的数据结构中。
3、当存在hash冲突时，在数组后面以链表的形式追加到后面，当链表长度达到8时，就会将链表转换为红黑树。
removeNode方法
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;
//tab :引用当前 hashMap 中的散列表
//p :当前 node 元素
//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;
//node :查找到的结果
//e :当前 Node 的下一个元素
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)))) {
//判断 node 不为空的话,说明按照 key 查找到需要删除的数据了
if (node instanceof TreeNode)
//第一种情况: node 是树节点,说明需要进行树节点移除操作
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
//第二种情况:桶位元素即査找结果,则将该元素的下一个元素放至桶位中
tab[index] = node.next;
else //第三种情况:将当前元素 p 的下一个元素设置成要删除元素的下一个元素
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}treeifyBin方法
treeifyBin方法，应该可以解释为：把容器里的元素变成树结构。当HashMap的内部元素数组中某个位置上存在多个hash值相同的键值对，这些Node已经形成了一个链表，当该链表的长度大于等于9的时候，会调用该方法来进行一个特殊处理。
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
/*为空或者容量小于MIN_TREEIFY_CAPACITY（默认64）则不
进行转换，而是进行resize扩容*/
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do { //循环遍历链表，切换为红黑树
TreeNode<K,V> p = replacementTreeNode(e, null);
//根据链表的node创建treenode
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);
}
}
617
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
