浅析HashMap（基于JDK1.8）
- HashMap基于JDK1.8的类定义
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
- 基本原理
HashMap是一个基于map实现的散列表，key允许为空值，但因为key不允许重复，所以只允许一个key为null
HashMap的查询和存储都是依赖于Hash算法
在1.7的情况下，使用的是数组+链表的数据结构，并且链表插入使用的是头插法，这样就导致了之前所说过得环状链表和丢失数据的问题，而在1.8之后整体结构使用的是数组+链表+红黑树，并且插入策略改成了尾插法，规避掉了扩容时逆序的情况，从而解决了1.7的弊病，但是无论如何HashMap都是一个不安全的，所以在多线程情况下不要使用HashMap
HashMap的1.7的时候查询链表的时间复杂度是O(n)，而在1.8的时候由于使用了红黑树的结构，他查询的时间复杂度是O(log n)
- 特性
HashMap的散列表是懒加载机制，在第一次put的时候才会创建
HashMap是无序不重复的，并不是线程安全的
HashMap只允许一条key为null的值存储，但是可以支持多条value为null的数据
如果在多线程的情况下你实在是想要用HashMap，可以用 Collections 的 synchronizedMap 方法使 HashMap 具有线程安全的能力
- 整体的数据结构图
- 源码解析
属性默认值
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
//序列号，序列化的时候使用
private static final long serialVersionUID = 362498820763181265L;
//初始的默认容量大小，默认为16，也就是2的4次方
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量，为2的30次方。
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;
//当整个hashMap中元素数量大于64时，也会进行转为红黑树结构。
//HashMap 的最小树形化容量。这个值的意义是：位桶（bin）处的数
//据要采用红黑树结构进行存储时，整个Table的最小容量（存储方式由
//链表转成红黑树的容量的最小阈值） 当哈希表中的容量大于这个值
//时，表中的桶才能进行树形化，否则桶内元素太多时会扩容，而不是
// 树形化为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 *
// TREEIFY_THRESHOLD
static final int MIN_TREEIFY_CAPACITY = 64;
}
属性参数
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
//HashMap的Node数组
transient Node<K,V>[] table;
//将数据转换成set的另一种存储形式，这个变量主要用于迭代功能。
transient Set<Map.Entry<K,V>> entrySet;
//元素数量
transient int size;
//统计该map修改的次数，用来记录 HashMap 内部结构发生变化的次数，主要用于迭代的快速失败机制
transient int modCount;
//HashMap 的门限阀值/扩容阈值，所能容纳的 key-value 键值对极 //
// 限，当size>=threshold时，就会扩容，计算方法：容量capacity * 负
// 载因子load factor 。
int threshold;
//加载因子
final float loadFactor;
}
构造方法
// 默认初始化容量+默认负载因子
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
// 自定义初始化容量+默认负载因子
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
// 自定义初始化容量以及负载因子
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);
}
put方法
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;
//首先在这里会判断table为空或者lenth的长度为0的时候
//会按默认方式对数组进行初始化，因为是懒加载
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//这里会判断当前节点上是不是为null，也就是table[i]=null这种情况，没有的话就直接插入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//这里判断了当前节点不为空时，也就是table[i]是不是传入的值，是的话就覆盖
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) {
//这里会进行判断，如果遍历链表之后并没有找到这个key
//那么就插入一个新的值，插入之前会进行判断，判断当前链表是不是已经到了阈值-1长度
//如果已经到了阈值，就会对当前链表进行树化
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;
}
}
//这里就是如果存在就将它的旧值替换成新值，之后返回旧值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//记录结构变换的次数
++modCount;
//如果数组长度已经到达了阈值，那么就进行扩容操作
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
hash方法
//对key做hash操作，其实就是将key的hashcode值获取出来，高位16位与低位16位做异或操作
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
resize方法
final Node<K,V>[] resize() {
//获取原来的数组
Node<K,V>[] oldTab = table;
//old数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//oldCap > 0也就是说不是首次初始化，因为hashMap用的是懒加载
if (oldCap > 0) {
//判断老的数组长度，如果大于最大值了，就将临界值设置为Integer最大取值
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
}
//如果oldCap<0，但是已经初始化了，像把元素删除完之后的情况，那么它的临界值肯定还存在，
//如果是首次初始化，它的临界值则为0
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//这里就是初始的扩容，一切按照默认的进行设置
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;
//这里开始判断当前这个节点是不是为null
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//判断这个节点是不是唯一节点，如果是那么就做hash操作，将其直接放进新数组
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
//新建两条链表，因为1.8之后已经不是之前全部元素做hash来移位的方法
//而是通过两条链表，一条放在原数组位置，一条放在原数组+扩容大小的位置
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//这里也就是判断这个点的hash值与上老数组长度是否为0
//为0的话将入到不移动的那条链表上
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//不为0加入到移动的那条链表上
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;
}
split方法，也就是对于红黑树的切割处理
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
TreeNode<K,V> b = this;
//这里其实也大致与链表相同，同样是分出来两个树，一个位置不变，一个位置变动
//区别仅在于这里到最后会有一个红黑树转链表的判断
//当不符合红黑树的条件时，会进行去树化，重新退化成链表
// Relink into lo and hi lists, preserving order
TreeNode<K,V> loHead = null, loTail = null;
TreeNode<K,V> hiHead = null, hiTail = null;
int lc = 0, hc = 0;
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
if ((e.hash & bit) == 0) {
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
++lc;
}
else {
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
++hc;
}
}
if (loHead != null) {
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map);
else {
tab[index] = loHead;
if (hiHead != null) // (else is already treeified)
loHead.treeify(tab);
}
}
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}
get方法
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;
}
remove方法
public V remove(Object key) {
//临时变量
Node<K,V> e;
/**调用removeNode(hash(key), key, null, false, true)进行删除，第三个value为null，表示，把key的节点直接都删除了，不需要用到值，如果设为值，则还需要去进行查找操作**/
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
/**第一参数为哈希值，第二个为key，第三个value，第四个为是为true的话，则表示删除它key对应的value，不删除key,第四个如果为false，则表示删除后，不移动节点**/
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
//tab 哈希数组，p 数组下标的节点，n 长度，index 当前数组下标
Node<K,V>[] tab; Node<K,V> p; int n, index;
//哈希数组不为null，且长度大于0，然后获得到要删除key的节点所在是数组下标位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
//nodee 存储要删除的节点，e 临时变量，k 当前节点的key，v 当前节点的value
Node<K,V> node = null, e; K k; V v;
//如果数组下标的节点正好是要删除的节点，把值赋给临时变量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不再是数组下标的节点，而是要删除结点的上一个结点**/
p = e;
} while ((e = e.next) != null);
}
}
//找到要删除的节点后，判断!matchValue，我们正常的remove删除，!matchValue都为true
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;
/**此方法在hashMap中是为了让子类去实现，主要是对删除结点后的链表关系进行处理**/
afterNodeRemoval(node);
//返回删除的节点
return node;
}
}
//返回null则表示没有该节点，删除失败
return null;
}
PS：都是在学中总结的，有错误希望各位可以及时指正
扫一扫
269
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
