hashmap1.8的数据结构有所变化,hashmap1.8以前的数据结构是数组+链表。现在的数据结构是数组+链表+红黑树。在1.8以前,如果在某个数组中,出现了hash碰撞,并且key不相同的情况下,就会生成一个链表。随着元素的增多,链表可能会越来越长,我们在去查找的时候,遍历单链表会需要很长的时间,时间复杂度为O(n)。但在1.8以后,加了红黑树,在单链表长度大于8,并且数组元素大于64时,会将链表转化为红黑树,这样将会提高很大的效率,增删改查的时间复杂度为O(logn)。
1.8版本hashmap的put流程图如下:
源码关键属性:
static final int `DEFAULT_INITIAL_CAPACITY*`= 1 << 4; // aka 16 默认初始容量为16
static final int `MAXIMUM_CAPACITY` = 1 << 30; //最大容量 恰好为int的最大值除以2
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; //最小树化容量为64
int threshold; // hashmap阈值
final float loadFactor; //负载因子
构造方法:
public HashMap() {
// 这里跟1.7的构造方法有一点不一样,但都是在put的时候进行初始化。加载因子为0.75
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
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;
// 还是老样子,传入的值必须是2的幂次方。方法在下面,我给大家贴出来了。这里的threshold目前是传入的容量,之后再初始化的时候,会进行重新赋值,即 容量*加载因子
this.threshold = tableSizeFor(initialCapacity);
}
// 传入一个map集合的构造方法
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
// 当前集合元素数量
int s = m.size();
if (s > 0) {
// 如果table为空,进行初始化,根据当前元素数量/加载因子得出数组总长度。
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
// 数组长度总是2的幂次方
if (t > threshold)
threshold = tableSizeFor(t);
}
// 如果当前元素数量大于阈值,进行扩容
else if (s > threshold)
resize();
// 遍历集合中的元素,进行put,放入我们要放入的集合中
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
在初始化数组长度时,我们会把数组长度确定为离这个数最近的大于它的2次幂,比如我们想初始化长度为6,那么会调用函数算出为8,赋值其实是8,而改为2次幂的函数使用的位运算也值得我们去学习:
static final int tableSizeFor(int cap) {
int n = cap - 1; // 17
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;
}
put方法:
public V put(K key, V value) {
// 将key进行hash,传入key value
// onlyIfAbsent:如果为true,新key与旧key 的键值对都相等的情况下,不会再覆盖原来的值。
// evict:如果为false,则表处于创建状态
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;
// 此时的表为空以及表的长度为0,会进行对表的初始化。
if ((tab = table) == null || (n = tab.length) == 0)
// resize后面会有讲到。 扩容用的
n = (tab = resize()).length;
// 求出下标之后,如果下标对应数组的位置没有元素的话,对于链表来说就是头节点,所以直接放入。这里使用的是尾插法。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null)
else {
Node<K,V> e; K k;
// 如果当前位置有元素,并且与此时位置上的key相等,那么让e引用p。p是当前位置上的元素,此时这个if分支已经走完了。直接到下面了
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 {
// 这里就是对链表的遍历啦,如果是链表那么元素不会超过8个。
// 遍历时,binCount的值从0开始,为0,1,2,3,4,5,6,7。也就是说binCount为7时,链表中的元素已经8个了,再加上我们传进来的这个key,一共9个元素,此时就会进行树化。
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;
}
// 这里如果找到了,那么break跳出for循环,执行下面的if分支,进行值的覆盖
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;
}
}
// 结构被修改了,要++的
++modCount;
// 如果此时size大于了阈值,要扩容的。
if (++size > threshold)
resize();
afterNodeInsertion(evict);
//如果没找到值,就返回null
return null;
}
treeifyBin(链表长度为8时调用用来转换为红黑树)
树化方法,在put时如果链表长度为8时会调用此方法,但是前提数组长度要大于64,否则只会进行扩容,并不会进行树化操作
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 如果表为null或者表的长度小于最64,不会进行树化,进行扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
// 根据hash做与运算,得到下标,拿到首节点,如果不为空。
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null; // hd:头节点 t1:尾节点
// 这里的dowhile循环会让单链表转为一个双向链表
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);
}
}
TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
// 转为树节点
return new TreeNode<>(p.hash, p.key, p.value, next);
}
treeify方法(转化为真正的树) :
final void treeify(Node<K,V>[] tab) {
// 红黑树的根节点
TreeNode<K,V> root = null;
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next;
x.left = x.right = null;
// 刚进入方法时,红黑树根节点此时一定为null,将链表的第一个节点作为根节点,颜色为黑色。
if (root == null) {
x.parent = null; // 根节点没有父节点
x.red = false; // 黑色
root = x; // 当前第一个节点给到root
}
else { // 这个分支说明已经有根节点了,与根节点的hash值进行比较
K k = x.key; // 此时的x是双向链表中的第二个节点
int h = x.hash; // x的hash值
Class<?> kc = null;
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
if ((ph = p.hash) > h)
dir = -1; // 往树的左方向走
else if (ph < h)
dir = 1; // 往树的右方向走
else if ((kc == null && // 如果p的hash值与x的hash值相等,则比较key值,如果key没有实现comparable接口或者x的key值和p的值相等,则使用一套自定义的规则来比较节点x和节点p的大小,用来决定时向左走还是向右走。
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
// 判断插入左子树还是右子树 dir<0则左边插入,dir>0则右边插入,如果为null那么当前位置就是x的目标位置
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
// 插入完成后,进行左旋右旋变色等操作,需要满足红黑树的特点。
root = balanceInsertion(root, x);
break;
}
}
}
}
moveRootToFront(tab, root);
}
putTreeVal(如果数组下标是红黑树则使用红黑树插入方法)
当我们put一个key时,此时数组下标对应的位置如果是一个TreeNode对象时,就会使用红黑树的插入方法。
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
// root()方法是返回红黑树的根节点
TreeNode<K,V> root = (parent != null) ? root() : this;
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
// 比较旧key与新key的hahs值,如果大于为-1,如果小于为1
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
// 如果此时根节点与传入的key相等,直接返回p
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
// kc上面已经赋值为null,所以对于短路与来讲,comparableClassFor(k)此方法必会执行。
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
// 在通过 hash 值跟 k 比较不出的情况下,则判断插入的 key 是否
// 是 Comparable 类型,以及两个类是否属于同一类型,如果是则
// 调用 compareTo 比较两个 key 的大小,如果无法比较则从当前
// 节点开始,查询所有子节点是否存在 key 相等的情况,如果有就
// 直接返回。
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
// 左子树不为空,先查左子树
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
// 右子树不为空,先查右子树
(q = ch.find(h, k, kc)) != null))
// 返回key
return q;
}
dir = tieBreakOrder(k, pk);
}
// 往树节点中插入此key
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
// 插入完后进行平衡(balanceInsertion()方法),左旋右旋变色等操作。此树还有一个隐藏的双向链 表,确保给定的根节点是双向链表的头节点。
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
resize扩容方法:
final Node<K,V>[] resize() {
// 旧数组
Node<K,V>[] oldTab = table;
// 如果数组为0,说明未进行初始化,后面会进行初始化,否则返回表的length
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 获取阈值
int oldThr = threshold;
int newCap, newThr = 0;
// 如果旧数组的容量大于0
if (oldCap > 0) {
// 旧数组容量是否大于最大支持容量
if (oldCap >= MAXIMUM_CAPACITY) {
// 阈值设置为最大,因为容量已经最大了,不能再扩容了。
threshold = Integer.MAX_VALUE;
// 返回旧值
return oldTab;
}
// 阈值为2倍,比如默认容量为16,阈值为12,然后下次扩容为32,那么阈值就是24。所以进行左移
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
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 进行初始化,默认容量为16 newThr重新计算阈值 容量*加载因子
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 计算新的resize()上限
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;
// 如果下一个元素为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;
// 旧数组往新数组上进行转移
// 这个循环对旧数组上的元素进行重hash优化 以0和1分隔
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;
}
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);
}
}
}