HashMap
HashMap是数组加上单链表的形式
# 构造函数
public HashMap() {
// 4, 0.75f
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
# put
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// 哈希算法, 不讨论
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
// 初始化数组容器, 长度为4
inflateTable(threshold);
}
if (key == null)
return putForNullKey(value);
// 计算哈希值
int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key);
// int i = 哈希值 & (数组长度-1); 是为了不超出下标
int i = indexFor(hash, table.length);
for (HashMapEntry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
// 匹配 对应的key, 和哈希值
// 如果匹配到覆盖原值
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
// 没有匹配到, 链表中添加新的节点
addEntry(hash, key, value, i);
return null;
}
// key 为 NULL 时的方法
private V putForNullKey(V value) {
// e 赋值为 tabel[0], 可见将 key为 null, 分配到了数组中的0下标
for (HashMapEntry<K,V> e = table[0]; e != null; e = e.next) {
// e 不为空, 并且key == null时, 覆盖旧value
if (e.key == null) {
V oldValue = e.value;
e.value = value;
// 给子类重写, 空方法
e.recordAccess(this);
return oldValue;
}
}
modCount++;
// int hash, K key, V value, int bucketIndex
addEntry(0, null, value, 0);
return null;
}
// 给链表添加元素
void addEntry(int hash, K key, V value, int bucketIndex) {
// 当存储的元素 >= 阈值(默认为3) 并且数组当前下标中的元素不等于空
if ((size >= threshold) && (null != table[bucketIndex])) {
// 以原数组长度的2倍扩容
resize(2 * table.length);
hash = (null != key) ? sun.misc.Hashing.singleWordWangJenkinsHash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
// bucketIndex为要放进容器的下标
// 创建 Entry插入到 table数组 bucketIndex下标链表中的头部
void createEntry(int hash, K key, V value, int bucketIndex) {
HashMapEntry<K,V> e = table[bucketIndex];
// 哈希值, key, value, next指针
table[bucketIndex] = new HashMapEntry<>(hash, key, value, e);
size++;
}
// 扩容数组
void resize(int newCapacity) {
HashMapEntry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
HashMapEntry[] newTable = new HashMapEntry[newCapacity];
transfer(newTable);
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
// 将原有数据迁移到扩容后的数组当中
void transfer(HashMapEntry[] newTable) {
int newCapacity = newTable.length;
// 外不循环, 遍历远table元素
for (HashMapEntry<K,V> e : table) {
// 内部循环, 遍历table元素中的链表
while(null != e) {
HashMapEntry<K,V> next = e.next;
// 根据新的数组长度重新计算下标
int i = indexFor(e.hash, newCapacity);
// 相当于将 Node e插入到当前下标链表中的头部
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
# get
public V get(Object key) {
if (key == null)
return getForNullKey();
// 根据key 获取对应的 Entry
Map.Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
// 获取 key 为 NULL的 value
private V getForNullKey() {
if (size == 0) {
return null;
}
// 在 下标为0的 链表中循环查找
for (HashMapEntry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
final Map.Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
// 遍历链表
for (HashMapEntry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
// 匹配 哈希值和 key
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
# remove
public V remove(Object key) {
Map.Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.getValue());
}
final Map.Entry<K,V> removeEntryForKey(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
int i = indexFor(hash, table.length);
HashMapEntry<K,V> prev = table[i];
HashMapEntry<K,V> e = prev;
while (e != null) {
HashMapEntry<K,V> next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
// prev == e 表明第一次循环就中标
if (prev == e)
table[i] = next;
else
// 前一个Node 连接 nextNode
prev.next = next;
// 子类重写, 空方法
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
# entrySet()
// entrySet() 和 keySet() 都是一个意思
private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}
// EntrySet
public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
HashMapEntry<K,V>[] tab;
if (action == null)
throw new NullPointerException();
if (size > 0 && (tab = table) != null) {
int mc = modCount;
// 外部循环遍历 tab 数组
for (int i = 0; i < tab.length; ++i) {
// 内部循环 遍历链表
// 规则是从 下标 0开始遍历链表, 链表结束后 在遍历下标1 ...
for (HashMapEntry<K,V> e = tab[i]; e != null; e = e.next) {
action.accept(e);
// 等号不成立, 说明出现了并发错误
if (modCount != mc) {
throw new ConcurrentModificationException();
}
}
}
}
}
// HashIterator
// KeySet 调用 iterator 会调用该方法获取Entry, 在调用getKey
// 规则也和 foreach() 一样也是从下标0开始 遍历
final Map.Entry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
HashMapEntry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
if ((next = e.next) == null) {
HashMapEntry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
current = e;
return e;
}
LinkedHashMap
LinkedHashMap继承于HashMap, 利用双向循环链表保证顺序
# init
void init() {
// 初始化header, before和after都指向自己
header = new LinkedHashMapEntry<>(-1, null, null, null);
header.before = header.after = header;
}
# put
void createEntry(int hash, K key, V value, int bucketIndex) {
HashMapEntry<K,V> old = table[bucketIndex];
LinkedHashMapEntry<K,V> e = new LinkedHashMapEntry<>(hash, key, value, old);
table[bucketIndex] = e;
// 到上面和 HashMap一样, 插入到当前下标链表的头部
e.addBefore(header);
size++;
}
// 该方法传入 header
// 如果说双向循环链表中 header为头部, 那么这里就是插入到队尾
private void addBefore(LinkedHashMapEntry<K,V> existingEntry) {
// 新元素 after 指向 header
after = existingEntry;
// 新元素 before 指向队尾, 也有可能是header
before = existingEntry.before;
// 原队尾元素 after 指向新元素
before.after = this;
// header.before 指向新元素
after.before = this;
}
void transfer(HashMapEntry[] newTable) {
int newCapacity = newTable.length;
// 因为每个元素之前都有链表关系, 所以这里没有必要双重循环, 数组和链表
// 元素 e 从header.after开始
for (LinkedHashMapEntry<K,V> e = header.after; e != header; e = e.after) {
int index = indexFor(e.hash, newCapacity);
e.next = newTable[index];
newTable[index] = e;
}
}
# remove()
void recordRemoval(HashMap<K,V> m) {
remove();
}
private void remove() {
before.after = after;
after.before = before;
}
# foreach()
public void forEach(BiConsumer<? super K, ? super V> action) {
if (action == null)
throw new NullPointerException();
int mc = modCount;
// header.after 开始直到 header为止, header不参与
for (LinkedHashMapEntry<K,V> e = header.after; modCount == mc && e != header; e = e.after)
action.accept(e.key, e.value);
if (modCount != mc)
throw new ConcurrentModificationException();
}
