基础操作, 基础结构
内部使用的是 数组 + 链表, 红黑树
不指定的话, 数组默认的大小是 16, 负载因子是 0.75
如何计算hash
- hash: 计算 key.hashCode 并将其高位传播(XOR) 到低位. 因为hash表使用的是 2次幂的掩码(2进制全1), hash码集合在当前掩码上变化的话总是会冲突.
线程安全
不是线程安全的, 如果某个线程进行了结构性修改, 必须要有外部的同步机制. 仅仅是修改 hashmap 中已存在的 key 所关联的值不算结构性修改
要实现线程安全, 通常使用synchronized关键字, 或者是使用 Collections.synchronizedMap 包装map(最好是在创建 map 的时候就使用, 否则可能会导致非线程安全的调用).
Map m = Collections.synchronizedMap(new HashMap(...));
操作
插入
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还没初始化的, 则执行初始化
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<K,V> e; K k;
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) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//节点数目达到8个, 转化成红黑树
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;
}
- table 的初始化是在第一次 putVal 的时候
- size + 1 > threshold 的时候会扩容
- 节点比较, 先比较hash, 再比较 eqauls, 如果相等则啥也不干
- 树操作, 先通过链表构造一个双端队列,然后执行树化.
扩容
final Node<K,V>[] resize() {
Node<K,V>[] 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<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;
//不是链表则直接取余, newCap - 1 值为 n 位 1
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;
do {
next = e.next;
// oldCap 是 10000.. 的形式
//相当于利用 那位1分类, 分成两份, 低位链表放 j, 高位链表放 j + oldcap
if ((e.hash & oldCap) == 0) {//e.hash = key 的hash 高16 ^ 低16位
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);
//为什么这里要分成高位和低位?
//原来的链表根据 oldCap = (10..00) 中的最高位1的位置 old_1 分成两组
//计算下标的公式: 数组下标 tab_i = hash & (cap - 1)
//对于 hash & (oldCap -1) == 0 的 hash 来说,
//他们的新下标 newTable_i = hash & (oldCap << 1 - 1) = hash & (oldCap - 1)
//和原来一样, 所以没有变化
//而 hash & (oldCap -1) != 0 的 hash, 证明其 old_1 位是 1,
//也就是说他们 newTable_i 是原来的 tabl_i 将 old_1 位置 1
//这个置 1 操作正好等于加 oldCap (因为 oldCap = 10..00)
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
删除
大同小异, 找到位置, 然后删除, 主要还是得处理树节点.
迭代
返回的是一个内部类: Values
final class Values extends AbstractCollection<V> {
public final int size() { return size; }
public final void clear() { HashMap.this.clear(); }
public final Iterator<V> iterator() { return new ValueIterator(); }
public final boolean contains(Object o) { return containsValue(o); }
public final Spliterator<V> spliterator() {
return new ValueSpliterator<>(HashMap.this, 0, -1, 0, 0);
}
public final void forEach(Consumer<? super V> action) {
Node<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next)
action.accept(e.value);
}
if (modCount != mc)
throw new ConcurrentModificationException();
}
}
}
FastFail
在所有 iterator 被创建之后,如果 hashmap 被进行了结构化的修改(除了iterator本身的remove调用)之后, 就会抛ConcurrentModificationException 异常, 在面对同步修改的时候, 能尽快抛出异常, 所以说是 FastFail.
FF在线程不安全的修改的时候可能会失效, 所以不能用其来作为程序的依赖, 而仅仅应该用来检测bug而已.
FF的原理很简单, 在修改hash结构的时候, modCount 变量 +1, 比如 add, remove 操作的时候. 然后在创建 Iterator 的时候, 就记录这个 modCount, 每次调用 next 方法的时候, 就检查一下当前的 modCount 和 当时保存的 modCount 是不是一致,不一致就抛异常.
forEach 也是这样, 操作前保存 modCount , 调用 consume 之后, 检查 modCount.
性能
get, put 操作都是常量的时间, 因为把元素都分散到不同的 bucket 中. 对集合的迭代时间跟 hashmap 的 capacity (bucket的数量) * size (键值对的数量) 成比例, 所以如果对迭代的性能要求很高, capacity 不要设太高, 负载因子(reload factor)不要设太低.
capacity 决定了 hashmap 的初始容量, 负载因子决定什么时候扩容. 当键值对达到 capacity * 负载因子的时候, 会重新扩容(内部数据结构的重建). 这样 hash 表 大概是 bucket 的数量的2倍.
通常来说, 负载因子 取 .75 最好地平衡了性能和空间开销. 设置 capacity 的时候要考虑这个负载因子. 当 hash 表的中 初始数量 大于 最大可能的元素数目 / 负载因子 的时候, 就不会发生扩容.
太多个key使用相同的 hashCode() 的时候, 会大大的影响性能.
衍生结构
- HashTable: 说衍生的话, 应该是 HashMap 从 HashTable 衍生过来, 区别在于 HashTable 是线程安全的, 但是不允许使用 null 的 key 或者 value; HashMap是线程的不安全的, 但是允许 null 的 key 和 value
算法
寻找大于某数的最小2次幂数
整个原理有点像细胞分裂(最大化复制黏贴), 我们考虑最高位的1, 在 n |= n >>> 1 之后, 最高的2位都变成了1; 在 n|=n>>>2 之后, 最高的4位变成了1; 依次类推, 最后总能得到一个全 1 的数, + 1 之后就变成进一位高位为 1, 其余为 0 的数字, 也就是 2次幂数.
现在来考虑特殊情况, 如果 cap 为 0, n = -1 , 变成负数, 符号位是 1 , 最后的数也是负数, 直接返回1.
扫一扫
273
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
