1. 变量
这些变量可能会在源码阅读中反复出现
- capacity: 容量,桶的数量 也就是table长度
- threshold:临界值,默认16(capacity*loadFactor)当size大于threshold的时候会进行resize
- loadFactor:加载因子 默认 0.75 减少hash冲突
- modCount:数据修改次数 Iterator初始化的时候(HashIterator构造函数)expectedModCount = modCount。在使用迭代器遍历的时候判断两个值是否一致,如果调用map的put或者remove则 modCount会变化,则会报异常,所以要用迭代器的remove方法。
- size:当前元素个数 put 的时候增加(createEntry方法) remove的时候减少 (removeEntryForKey)
2.构造函数
使用规定的容量和加载因子来创建
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;
threshold = initialCapacity;
init(); // HashMap中此方法未实现,LinkedHashMap有相应的实现
}
使用已经存在的map对象来构建HashMap
public HashMap(Map<? extends K, ? extends V> m) {
// 取16和 size/0.75 + 1 较大值,使用默认加载因子0.75
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
inflateTable(threshold);
putAllForCreate(m);
}
填充table,如果table为空,初始化 table 为 x 且 x 为 2的n次数 >= threshold 之后resize 的时候 都是 table.length * 2 所以长度都是2的倍数
private void inflateTable(int toSize) {
// roundUpToPowerOf2 中确保 toSize >= 0 ,返回一个最接近 toSize 的次方数
int capacity = roundUpToPowerOf2(toSize);
// threshold 最大不能超过 (1 << 30) + 1
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
3.put源码
首先来张图整体感受下流程
put方法
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
// 如果 key 为空 则特殊处理(因为下面调用key对象的hash()方法,null无法调用hash方法,会空指针)
if (key == null)
return putForNullKey(value);
// 获取 key 的 hash 并获取 hash 在 table.length 的第 i 个
int hash = hash(key);
int i = indexFor(hash, table.length);
// 获取 tabel[i] 的 entry, 如果为空或者链表中不存在对应的key,则调用addEntry方法
// 如果匹配到,则用新值替换旧值,返回 oldValue
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
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;
}
putForNullKey
// 循环table 查看是否有 key 为null的 entry 有则话用新值替换旧值,并直接return
// 如果没有key为null 则调用 addEntry 方法 并放入table的第 0 位 (null 的 hash 都认为是 0 )
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}
addEntry
void addEntry(int hash, K key, V value, int bucketIndex) {
// 如果 size 大于等于 threshold 且 table[i] 不为空(说明要在table上面添加新的元素需要调用resize方法)
if ((size >= threshold) && (null != table[bucketIndex])) {
resize(2 * table.length); // table扩容
hash = (null != key) ? hash(key) : 0; // 对于key重新获取 hash
bucketIndex = indexFor(hash, table.length); // 重新获取在table上的位置
}
// 新建节点
createEntry(hash, key, value, bucketIndex);
}
createEntry
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e); // 将新放入的值至于链表的头部
size++; // 大小增加
}
4.扩容
查看resize方法
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
// 如果table长度已经为最大值则不处理
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity)); // 将
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
transfer 用新数组的length 重新获取每个key 的 index 值 并将每个放入新的table
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) { // 如果需要rehash 则重新用新的hashseed来获取hash
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}