- HashMap支持null key 和null value, HashTable不允许空的value?
- 遍历的成本 == key的总数+n(cap) 因此不要把最初的cap设置成太高，否则可能遍历的效果是低效的，或者把load factor设置得太低
- 默认的loadFactor是0.75,是综合容量和遍历的时间的考虑进行设置的，如果设置得更高的话，那么可能会减少空间负担（因为更多的空间可以用来放元素）但是会增加查找的成本
- HashMap不是线程安全的，需要自己做线程同步
里面计算表大小的函数，感觉很有用，记录下来
// 找到大于等于当前数的最小的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;
}
get方法
下面就我们最常用的get方法分析一下查找的过程
public V get(Object key) {
Node e;
// 调用了getNode方法
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node getNode(int hash, Object key) {
// 需要保证数组的大小是2的倍数，hash的每一位才会被充分利用
Node[] tab; Node first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 检查第一个节点的hash和key数值是否相等，如果相等那么当前节点命中
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
// 此时的hash已经树化了;用树的节点去查找，这里暂时不关注树化
if (first instanceof TreeNode)
return ((TreeNode)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;
}
HashMap为了防止过多节点都hash到一个桶里面，导致了查找效率的降低，因此在某一个桶的节点的数量超过阈值8的时候，会进行“树化”，具体的树化的流程在我们分析完正常的插入流程之后再去分析，那么这里为什么是8呢，我们假设外部的输入是随机且均匀的，那么最终每个桶拥有节点的数量应该服从参数为0.5的泊松分布，前提（loadFactor = 0.75),根据此概率计算，发现每个桶如果多于8个节点的概率小于亿分之一，那么将8作为树化的阈值是可行的（树化是少有发生的),同时当桶的节点小于某个数值的时候，树化的节点应该重新恢复成之前的链表，这里HashMap源码指定了6,这是因为恢复的阈值理所应当地小于树化的阈值，能不能小于6呢，后续的流程在分析
resize方法
可以看到，当发现table为空，或者大小为0的时候，调用了resize方法，其他的调用时机则是当插入触发factor的上限的时候，这个时候会对当前的数组大小加倍，对于初始的情况，会直接使用threshold里面的数值作为初始容量
final Node[] resize() {
Node[] oldTab = table;
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
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[] newTab = (Node[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node 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)e).split(this, newTab, j, oldCap);
else { // preserve order
Node loHead = null, loTail = null;
Node hiHead = null, hiTail = null;
Node 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;
}
插入流程
// 如果返回为空，那么代表着可能之前没有往里面放数值或者之前放了一个空的
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// onlyIfAbsent 如果原来的key存在，那么不改动原始的值，evit我们不去理会，直接当成false就好了
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
// 第一次插入，首先扩容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 桶还是空的；直接将元素放在桶里
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node e; K k;
// 和当前节点的key相同，直接替换
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode)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;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 提交给LinkedHashMap的回调
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 如果当前的size超过了threshold；那么执行resize
if (++size > threshold)
resize();
// 提供给LinkedHashMap的回调
afterNodeInsertion(evict);
return null;
}
// Create a regular (non-tree) node
Node newNode(int hash, K key, V value, Node next) {
return new Node<>(hash, key, value, next);
}
抛开树化的代码，我们看一下
- 最上面的部分将容量和阈值都扩充到之前的两倍
- 最下面涉及到元素移动的部分
- 如果原始的桶里只有一个元素，那么只移动它就可了
- 如果原始的桶里不只有一个元素，由于现在大小变成了之前的两倍，对于之前和原始尺寸进行hash计算，如果在oldCap1的位置不为0的话，那么这部分的元素需要移动到新的位置，实际上新的位置也就是原始的位置加上oldCap的位置，这部分的代码还是很巧妙的
- HashMap是懒惰加载，最开始的数组是null,只有插入的时候resize才会分配内存空间