@Test
    public void test() {
        Hashtable<String, String> table=new Hashtable<>();
        Hashtable<String, String> table1=new Hashtable<>(16);
        Hashtable<String, String> table2=new Hashtable<>(16, 0.75f);
        table.put("T1", "1");
        table.put("T2", "2");
        System.out.println(table);
        // 報空指針異常
        table.put(null, "3");
    }

// 內(nèi)部采用Entry數(shù)組存儲鍵值對數(shù)據(jù)，Entry實際為單向鏈表的表頭
private transient Entry<?,?>[] table;
// HashTable里鍵值對個數(shù)
private transient int count;
// 擴容閾值，當超過這個值時，進行擴容操作，計算方式為：數(shù)組容量*加載因子
private int threshold;
// 加載因子
private float loadFactor;
// 修改次數(shù)，用于快速失敗機制
private transient int modCount = 0;

private static class Entry<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Entry<K,V> next;

    protected Entry(int hash, K key, V value, Entry<K,V> next) {
        this.hash = hash;
        this.key =  key;
        this.value = value;
        this.next = next;
    }

    ......
}

// 設(shè)置指定容量和加載因子，初始化HashTable
public Hashtable(int initialCapacity, float loadFactor) {
    // 非法參數(shù)校驗
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                          initialCapacity);
    // 非法參數(shù)校驗
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal Load: "+loadFactor);

    if (initialCapacity==0)
        // 容量最小為1
        initialCapacity = 1;
    this.loadFactor = loadFactor;
    // 初始化數(shù)組
    table = new Entry<?,?>[initialCapacity];
    // 初始擴容閾值
    threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
}

// 設(shè)置指定容量初始HashTable，加載因子為0.75
public Hashtable(int initialCapacity) {
    this(initialCapacity, 0.75f);
}

// 手動指定數(shù)組初始容量為11，加載因子為0.75
public Hashtable() {
    this(11, 0.75f);
}

// 方法synchronized修飾，線程安全
public synchronized V put(K key, V value) {
    // 如果value為空，直接空指針
    if (value == null) {
        throw new NullPointerException();
    }

    // Makes sure the key is not already in the hashtable.
    Entry<?,?> tab[] = table;
    // 得到key的哈希值
    int hash = key.hashCode();
    // 得到該key存在到數(shù)組中的下標
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    // 得到該下標對應的Entry
    Entry<K,V> entry = (Entry<K,V>)tab[index];
    // 如果該下標的Entry不為null，則進行鏈表遍歷
    for(; entry != null ; entry = entry.next) {
        // 遍歷鏈表，如果存在key相等的節(jié)點，則替換這個節(jié)點的值，并返回舊值
        if ((entry.hash == hash) && entry.key.equals(key)) {
            V old = entry.value;
            entry.value = value;
            return old;
        }
    }
    // 如果數(shù)組下標對應的節(jié)點為空，或者遍歷鏈表后發(fā)現(xiàn)沒有和該key相等的節(jié)點，則執(zhí)行插入操作
    addEntry(hash, key, value, index);
    return null;
}

private void addEntry(int hash, K key, V value, int index) {
    // 修改次數(shù)+1
    modCount++;

    Entry<?,?> tab[] = table;
    // 判斷是否需要擴容
    if (count >= threshold) {
        // 如果count大于等于擴容閾值，則進行擴容
        rehash();

        tab = table;
        // 擴容后，重新計算該key在擴容后table里的下標
        hash = key.hashCode();
        index = (hash & 0x7FFFFFFF) % tab.length;
    }

    // Creates the new entry.
    @SuppressWarnings("unchecked")
    // 采用頭插的方式插入，index位置的節(jié)點為新節(jié)點的next節(jié)點
    // 新節(jié)點取代inde位置節(jié)點
    Entry<K,V> e = (Entry<K,V>) tab[index];
    tab[index] = new Entry<>(hash, key, value, e);
    // count+1
    count++;
}

protected void rehash() {
    // 暫存舊的table和容量
    int oldCapacity = table.length;
    Entry<?,?>[] oldMap = table;

    // 新容量為舊容量的2n+1倍
    int newCapacity = (oldCapacity << 1) + 1;
    // 判斷新容量是否超過最大容量
    if (newCapacity - MAX_ARRAY_SIZE > 0) {
        // 如果舊容量已經(jīng)是最大容量大話，就不擴容了
        if (oldCapacity == MAX_ARRAY_SIZE)
            // Keep running with MAX_ARRAY_SIZE buckets
            return;
        // 新容量最大值只能是MAX_ARRAY_SIZE
        newCapacity = MAX_ARRAY_SIZE;
    }
    // 用新容量創(chuàng)建一個新Entry數(shù)組
    Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
    // 模數(shù)+1
    modCount++;
    // 重新計算下次擴容閾值
    threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    // 將新Entry數(shù)組賦值給table
    table = newMap;
    // 遍歷數(shù)組和鏈表，進行新table賦值操作
    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;
        }
    }
}

public synchronized V get(Object key) {
    Entry<?,?> tab[] = table;
    int hash = key.hashCode();
    // 根據(jù)key哈希得到index，遍歷鏈表取值
    int index = (hash & 0x7FFFFFFF) % tab.length;
    for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            return (V)e.value;
        }
    }
    return null;
}

public synchronized V remove(Object key) {
    Entry<?,?> tab[] = table;
    int hash = key.hashCode();
    // 獲取key對應的index
    int index = (hash & 0x7FFFFFFF) % tab.length;
    @SuppressWarnings("unchecked")
    // 遍歷鏈表，如果找到key相等的節(jié)點，則改變前繼和后繼節(jié)點的關(guān)系，并刪除相應引用，讓GC回收
    Entry<K,V> e = (Entry<K,V>)tab[index];
    for(Entry<K,V> prev = null ; e != null ; prev = e, e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
            modCount++;
            if (prev != null) {
                prev.next = e.next;
            } else {
                tab[index] = e.next;
            }
            count--;
            V oldValue = e.value;
            e.value = null;
            return oldValue;
        }
    }
    return null;
}