HashMap1.8源码分析
简介
hashmap1.8的数据结构有所变化，hashmap1.8以前的数据结构是数组+链表。现在的数据结构是数组+链表+红黑树。在1.8以前，如果在某个桶(数组)中，出现了hash碰撞，并且key不相同的情况下，就会生成一个链表。随着元素的增多，链表可能会越来越长，我们在去查找的时候，遍历单链表会需要很长的时间，时间复杂度为O(n)。但在1.8以后，加了红黑树，在单链表长度大于8，并且数组元素大于64时，会将链表转化为红黑树，这样将会提高很大的效率，增删改查的时间复杂度为O(logn)。
数据结构
这里只是一个大致的结构。这里有一篇不错的文章，散列表结构。
源码中有两个参数，其中一个参数是衡量是否有转换为红黑树条件，另一个参数是转换红黑树要求数组长度大于64才能直接转红黑树。
// 用来衡量是否要转红黑树
static final int UNTREEIFY_THRESHOLD = 6;
//转红黑树需要的最小数组长度
static final int MIN_TREEIFY_CAPACITY = 64;
下面看源码，后面会有讲到。
源码分析
关键属性
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);
}
}
}
这个方法：比如传入的是18，那么实际返回的容量为32；传入8，实际容量就是8
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方法
- 当我们put一个值时
- 首先判断table表是否已经初始化，如果没有则进行初始化
- 计算该值存放到table中的哪个位置
- 找到位置后，如果该位置为null，则直接插入
- modCount++
- size++ 判断是否需要扩容
- 找到位置后，该位置不为null
- 判断当前位置的key是否与传入的key相等，如果相等，新值覆盖旧值，返回旧值。
- 如果与当前位置的key不相等，那么观察当前位置是否是棵红黑树
- 如果是红黑树，以树节点的方式插入
- 如果不是红黑树，则以链表的方式插入
- 遍历链表到尾尾节点，插入到尾节点的后面，然后计算此链表长度是否大于等于8。
- 如果大于等于8，需要进行树化操作，进入树化方法后，还需判断数组长度是否大于等于64，如果大于等于，则进行树化。否则，只进行扩容。
- 如果小于8，跳出循环，modCount++ size++，判断是否需要扩容。
- 插入成功后，返回null。
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;
}
putTreeVal红黑树插入方法
当我们put一个key时，此时数组下标对应的位置如果是一个TreeNode对象时，就会使用红黑树的插入方法。
过程：判断key是否与当前插入的key相等，若相同，则覆盖；若不同，则插入。
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;
}
}
}
treeifyBin
树化方法，但是前提数组长度要大于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);
}
moveRootToFront方法
这个方法是将最终旋转后得到的跟节点放入链表的头部。
过程：
- 如果当前索引位置的头节点不是root节点，则将root的上一个节点和下一个节点进行关联
- 将root放到头节点的位置，原来的节点放在root的next节点上，随后原来的节点的前驱几点指向root，root的后继节点指向原来的头节点
- 断言：检查树是否正常，将传入的节点作为根节点。遍历所有节点，检查节点的合法性，主要保证该数符合红黑树的规则。
这里可以用笔在纸上画一画，很容易就懂了。
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) { // 将root放入头节点的位置
int n;
if (root != null && tab != null && (n = tab.length) > 0) {
int index = (n - 1) & root.hash;
TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
if (root != first) {
Node<K,V> rn;
tab[index] = root;
TreeNode<K,V> rp = root.prev;
if ((rn = root.next) != null)
((TreeNode<K,V>)rn).prev = rp;
if (rp != null)
rp.next = rn;
if (first != null)
first.prev = root;
root.next = first;
root.prev = null;
}
assert checkInvariants(root);
}
}
find方法
查找红黑树某个值使用的方法
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
// this为当前root，因为遍历树，肯定要从根节点开始遍历
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
// pl为左子树，pr为右子树
TreeNode<K,V> pl = p.left, pr = p.right, q;
// 如果当前要查找的节点的hash值小于根节点，那么此节点就在左子树那一边。
if ((ph = p.hash) > h)
p = pl;
// 如果当前查找的节点的hash值大于根节点，那么此节点在右子树那一边。
else if (ph < h)
p = pr;
// 如果找到了相同的key，那么直接返回p
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
// 如果左子树为空，那么去查右子树
else if (pl == null)
p = pr;
// 如果右子树为空，那么去查左子树
else if (pr == null)
p = pl;
// 判断 k 是否是 Comaprable 类型，如果是继续判断当前节点的
// key 跟 k 是否是同一类型，如果是则调用 compareTo 方法
// 比较两值的大小
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
// 以上都不满足，则去右子树查找
else if ((q = pr.find(h, k, kc)) != null)
return q;
else
// 左子树下查找
p = pl;
} while (p != null);
return null;
}
tieBreakOrder方法
在 hashCode 相等且 key 均没有实现 Comparable 进行比较的情况下，调用该方法比较两个 key 的大小。这是一套自定义的规则，因为要判断此时的key在树中往哪个方向走。
// //比较顺序： 1、hashCode 2、compareTo（） 3、getClass().getName() 4、System.identityHashCode()
static int tieBreakOrder(Object a, Object b) {
int d;
if (a == null || b == null ||
(d = a.getClass().getName().
compareTo(b.getClass().getName())) == 0)
d = (System.identityHashCode(a) <= System.identityHashCode(b) ?
-1 : 1); //System.identityHashCode 是根据对象在内存中的地址算出来的hash值
return d;
}
comparableClassFor方法
此方法检查key是否实现了comparable接口，如果实现了，会使用comparaTo用来比较，比较完后返回；如果实现没有就返回null。
static Class<?> comparableClassFor(Object x) {
if (x instanceof Comparable) {
Class<?> c; Type[] ts, as; Type t; ParameterizedType p;
// 检查x是否是String类型
if ((c = x.getClass()) == String.class) // bypass checks
return c;
// c.getGenericInterfaces()方法返回的是一个接口数组
if ((ts = c.getGenericInterfaces()) != null) {
// 遍历数组
for (int i = 0; i < ts.length; ++i) {
// ParameterizedType检查泛型<>，如果为参数化类型，那么获取它的type。getRawType()方法就是type 。getActualTypeArguments()返回了一个Type数组,数组里是参数化类型的参数
综上所述，如果是comparable.class类型，直接返回
if (((t = ts[i]) instanceof ParameterizedType) &&
((p = (ParameterizedType)t).getRawType() ==
Comparable.class) &&
//
(as = p.getActualTypeArguments()) != null &&
as.length == 1 && as[0] == c) // type arg is c
return c;
}
}
}
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;
}
get方法
- 传入key的hahs值，与key
- 判断table是否为空且表的长度大于0，以及&操作得出下标，判断数组当前位置是否元素存在
- 判断头节点是否是我们要get的元素，如果是返回
- 如果头节点的下一个节点不为null，判断头节点是否是一棵红黑树，如果是树，那么以树节点的方式去获取，调用getTreeNode方法，然后里面其实也就是调用的find()方法。
- 如果不是树，那么遍历链表，找到返回
- 如果没有找到key，那么返回null
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;
}
面试题
hashmap1.7与hashmap1.8有什么不同？
| 区别 | 1.8 | 1.7 |
|---|---|---|
| 扩容后存储位置的计算方式 | 扩容后的位置=原位置或者原位置+旧容量 | 按照原来方法重新计算，hashcode经过扰动处理并于数组长度进行与操作 |
| 转移数据的方式 | 尾插法(直接插入到链表尾部/红黑树) | 头插法 （先将原位置的数据往后移动一位，再将数据插入到该位置） |
| 插入数据的时机 | 扩容前插入 | 扩容后插入 |
| 插入数据位置重新计算的时机 | 转移数据前统一计算 | 单独计算 |
| 存储的数据结构 | 数组+链表+红黑树 | 数组+链表 |
| 数组和链表节点的实现类 | Node类 | Entry类 |
| 初始化方式 | 直接继承在扩容函数resize() | 单独函数：inflateTable() |
| hash值的计算方式 | 扰动处理=2次扰动（1次位运算+1次异或运算） | 扰动处理=9次扰动（4次位运算+5次异或运算） |
| 存放数据规则 | 无冲突时放入链表/冲突且链表长度小于8存入单链表/冲突且单链表长度大于8存入红黑树 | 无冲突时，存放数组/冲突存放到单链表中 |
为什么采用哈希码与运算数组长度-1计算数组下标？
- 提高运算效率，计算下标的方式其实就是hash值对数组进行取模运算，所以为了等价所以必须 h&(length-1)。h&(length-1)等于 h%length。并且采用位运算可以提高效率
- 均匀分布在数组各个位置中，降低Hash冲突。
- 首先数组长度可为奇，也可为偶数，如果为奇数的话，那么你二进制最后一位肯定为1，如果在奇数上减1，最后一位就为0，那么你在与hash值进行与操作时，所有的下标都会是偶数，浪费了一半的存储空间，容易出现hash冲突。
- 如果数组长度为偶数，那么减1，最后一位就为1了，那么与hash进行与算法，可能得出来的数为奇也可能为偶数，保证了一个均匀分布。
- 解决哈希码与数组大小不匹配的情况
为什么HashMap中String、Integer这样的包装类适合作为key键？
- String、Integer等包装类的特性，保证了hash值的不可更改性以及计算准确性，有效的减少了hash碰撞的几率
- 包装类的特性，final类型，具有不可变性，保证了key的不可更改性，不会出现放入和获取哈希码不同的情况
- 内部重写了equals、hashcode方法，严格遵守相关规范，不容易出现hash值的计算错误
为什么HashMap具备下述特点：键-值(key-value)都允许为空、线程不安全、不保证有序、存储位置随时间变化？
- key、value为空：因为key为空时，hash值默认设置为0，只有有一个key为null。value不需要唯一，可以多个为null
- 线程不安全
- jdk1.7：没有同步锁保护，并发执行put操作导致触发扩容，从而导致环形链表，在获取数据遍历链表时形成死循环
- jdk1.8：没有同步锁保护，put，get依旧线程不安全
迭代器fail-fast快速失败策略，一旦在使用迭代器过程中出现并发操作，多个线程修改hashmap，会抛出ConcurrentModificationException异常
- 不保证有序：存储顺序根据hash算法计算的下标来进行排序，随机性
- 存储位置随时间变化：存在扩容操作，从而导致存储位置重新计算，发生变化
为什么不直接采用经过hashCode()处理的哈希码作为存储数组table的下标位置？
容易出现哈希码与数组大小不匹配的情况，计算出来的哈希码可能不在数组大小范围内，从而导致无法匹配存储位置hashmap的容量范围一般不会取到最大值，而且需求上并不需要这么多的存储空间，设备上也难以提供这么多的存储空间从而导致算出来的哈希码可能不在数组大小范围内，从而导致无法匹配存储位置。
为什么在计算数组下标前，需对哈希码进行扰动处理？
加大哈希码低位的随机性，使得分布更加均匀，从而提高对数组存储下标位置的随机性与均匀性，最终减少hash冲突
为什么引入红黑树？
在1.8以前，如果在某个桶(数组)中，出现了hash碰撞，并且key不相同的情况下，就会生成一个链表。随着元素的增多，链表可能会越来越长，我们在去查找的时候，遍历单链表会需要很长的时间，时间复杂度为O(n)。但在1.8以后，加了红黑树，在单链表长度大于8，并且数组元素大于64时，会将链表转化为红黑树，这样将会提高很大的效率，增删改查的时间复杂度为O(logn)。
关于默认容量为什么是16的问题？
查了一下资料，并没有什么信息。jdk官方并没有给出解释。2的幂比较均匀，散列吧。
关于加载因子为什么是0.75？
加载因子为什么是0.75 可以看下这篇文章。
总结
- hashmap1.8底层结构为数组+链表+红黑树，在数组的某一个位置上，如果存在多个节点，则可能是以链表或红黑树的形式存在
- hashmap在触发扩容后，阈值会变为原来的2倍，并且会对所有节点进行rehash分布。分布后的位置只可能有2个，原索引的位置或者原索引+旧容量(oldCap)位置。比如当前容量为32，索引位置7的节点扩容后，只可能会在原来的位置或者5+32的位置上。
- hashmap在初始化时，如果传入了初始化容量值，则会将该值赋值给threshold值，并且只有当我们put第一个元素的时候才会进行初始化，初始化时，根据我们传入的容量，进行再次运算，容量必须是2的幂次方。如果我们传入17，那么最终容量为32。并且会将此值作为新表的capacity值，然后用capacity*loadFactor计算出阈值。
- 当同一个索引位置的节点再增加后达到9个，并且此时数组的长度大于等于64，则会触发链表节点转为红黑树。转成红黑树后，链表的结构还会存在，通过next属性维持，包括还有一个隐藏的双向链表作为辅助，大家可以看一下TreeNode节点有一个prev指针。链表转节点的具体方法在treeifyBin方法中。如果数组长度小于64，并不会转为红黑树，而是进行扩容。
- 当同一个索引位置的节点在移除后达到6个，并且该索引位置为红黑树节点，会触发红黑树节点转成链表节点。代码逻辑在untreeify方法中。
- hashmap1.8之后不会有死循环的问题，hash1.8之前死循环的原因是在扩容时同一个索引位置的节点顺序颠倒。导致多线程下会出现死循环环形链表。
- hashmap1.8采用尾插法，hashmap1.8以前采用头插法
- hashmap还是存在线程安全的问题，两个线程同时进行put操作，这两个key的hash值一样，但数据不同，此时A线程进入，假设A线程还未进行数据插入时挂起，此时线程B正常执行，插入数据。然后A线程获取cpu时间片，此时线程A不会进行hash判断，直接将B线程的插入的数据直接覆盖。
- 在并发场景下可以使用ConcurrentHashMap来代替
分析就到这里了。。。这篇文章也不错，写的非常详细。hashmap1.8
384
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
