本文涉及的源码基于 JDK 1.8.0_101 。

1. HashTable

1. 采用数组 + 链表（表头插入）方式解决哈希冲突。

2. 所有的 public 方法都用 synchronized
   修饰以保证线程安全。

3. 在构造时就初始化槽数组（默认大小为 11
   ）。

4. 键、值 都不能为 null
   。

5. 指定 key 的目标槽的定位逻辑：(key.hashCode() & 0x7FFFFFFF) % table.length
   ，掩码+求模。

6. 槽数组的最大尺寸为 MAX_ARRAY_SIZE: Integer.MAX_VALUE - 8
   (减 8 是因为一些 JVM 会在数组里保留一些 header words)。

7. 扩容逻辑为 两倍 + 1。

8. 阈值为：(int)(capacity * loadFactor)
   ，但不能超过 MAX_ARRAY_SIZE + 1
   。

   
   

1.1 put 方法逻辑

1. 通过 key 计算出目标槽位 index ；

2. 遍历 table[index]
   链表，如果 key 存在，则替换 value，返回前值。

3. 如果 key 不存在，继续。

4. 判断元素数量是否达到阈值，达到的话进行扩容 rehash，然后重新计算目标槽位 index。

5. 创建新的 Entry，把 Entry 插入到链表的头部。

   
   

1.2 rehash 逻辑

1. 数组扩容至 oldCapacity * 2 + 1
   ，但不能超过 MAX_ARRAY_SIZE 。

2. 把旧 map 上的元素转移到新的 map：逐个槽位、逐个链表遍历 。

protected void rehash() {
    int oldCapacity = table.length;
    Entry<?,?>[] oldMap = table;


    // overflow-conscious code
    int newCapacity = (oldCapacity << 1) + 1;
    if (newCapacity - MAX_ARRAY_SIZE > 0) {
        if (oldCapacity == MAX_ARRAY_SIZE)
            // Keep running with MAX_ARRAY_SIZE buckets
            return;
        newCapacity = MAX_ARRAY_SIZE;
    }
    Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];


    modCount++;
    threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    table = newMap;


    for (int i = oldCapacity ; i-- > 0 ;) {
        for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
            Entry<K,V> e = old;
            old = old.next;


            int index = (e.hash & 0x7FFFFFFF) % newCapacity;
            e.next = (Entry<K,V>)newMap[index];
            newMap[index] = e;
        }
    }
}
复制

1.3 get 方法
复制

1. 计算 key 的目标槽位 index；

2. 遍历 table[index]
   上的链表以查找 key，找到返回 value、找不到返回 null 。

   
   

1.4 remove 方法

1. 计算 key 的目标槽位 index；

2. 遍历 table[index]
   上的链表查找 key，初始化前驱 prev 为 null，找到 key 的 entry e 后，如果 prev 不为 null 则设置 prev.next = e.next
   ，否则说明 e 就在链表的头部，设置 table[index] = e.next
   。

   
   

欢迎关注我的微信公众号: coderbee笔记 。