//The hash table data.

//底层维护一个Entry(键值对)数组

private transient Entry<K,V>[] table;

//The total number of entries in the hash table.

//元素总量，等同于HashMap的size

private transient int count;

//The load factor for the hashtable.

//负载因子

private float loadFactor;

/**

 * The table is rehashed when its size exceeds this threshold.

 * (The value of this field is (int)(capacity * loadFactor).)

 * 超过阈值进行rehash

 */

private int threshold;

/**

  * The number of times this Hashtable has been structurally modified

  * Structural modifications are those that change the number of entries in

  * the Hashtable or otherwise modify its internal structure (e.g.,

  * rehash).  This field is used to make iterators on Collection-views of

  * the Hashtable fail-fast.  (See ConcurrentModificationException).

  * 结构性变动时modCount计数+1，用于遍历时的fail-fast机制生效

  */

private transient int modCount = 0

/**

     * Constructs a new, empty hashtable with the specified initial

     * capacity and the specified load factor.

     */

    public Hashtable(int initialCapacity, float loadFactor) {

        if (initialCapacity < 0)

            throw new IllegalArgumentException("Illegal Capacity: "+

                                               initialCapacity);

        if (loadFactor <= 0 || Float.isNaN(loadFactor))

            throw new IllegalArgumentException("Illegal Load: "+loadFactor);

        if (initialCapacity==0)

            initialCapacity = 1;    //没有强调2次幂，cap为0时，默认是1

        this.loadFactor = loadFactor;

        table = new Entry<?,?>[initialCapacity];

        threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);

    }

    /**

     * Constructs a new, empty hashtable with a default initial capacity (11)

     * and load factor (0.75).

     * 容量11，负载因子 0.75

     */

    public Hashtable() {

        this(11, 0.75f);

    }    

public synchronized V put(K key, V value) {

    // Make sure the value is not null，而HashMap选择将key为null永远存放为table[0]位置

    if (value == null) {

        throw new NullPointerException();

    }

    // Makes sure the key is not already in the hashtable.

    //确保key不在hashtable中

    //首先，通过hash方法计算key的哈希值，并计算得出index值，确定其在table[]中的位置

    //其次，迭代index索引位置的链表，如果该位置处的链表存在相同的key，则替换value，返回旧的value

    Entry tab[] = table;

    int hash = hash(key);

    //计算下标，这里使用%方法，性能远不及HashMap的位运算 (这也是不推荐使用HashTable的原因之一)

    int index = (hash & 0x7FFFFFFF) % tab.length;

    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {

        //直接使用equals比较，而HashMap多了一层地址比较 `((k = e.key) == key || key.equals(k))`

        if ((e.hash == hash) && e.key.equals(key)) {

            V old = e.value;

            e.value = value;

            return old;

        }

    }

    //结构性变更操作 modCount计数+1

    modCount++;

    //HashMap选择新增addEntry方法封装一下逻辑

    if (count >= threshold) {

        // Rehash the table if the threshold is exceeded

        //如果超过阀值，就进行rehash操作

        rehash();

        tab = table;

        hash = hash(key);

        index = (hash & 0x7FFFFFFF) % tab.length;

    }

    // Creates the new entry.

    //将值插入，返回的为null

    Entry<K,V> e = tab[index];

    // 创建新的Entry节点，并将新的Entry插入Hashtable的index位置，并设置e为新的Entry的下一个元素

    tab[index] = new Entry<>(hash, key, value, e);

    //size++

    count++;

    return null;

}

public synchronized V get(Object key) {

        Entry tab[] = table;   //临时拷贝，保证数据的时效性

        int hash = hash(key);

        int index = (hash & 0x7FFFFFFF) % tab.length;

        for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {

            if ((e.hash == hash) && e.key.equals(key)) {

                return e.value;

            }

        }

        return null;

    }

/**

 * Created by roman on 2017/10/03.

 *【2017 java's day】

 */

public class ListHashTableTest {

    public static void main(String[] args) {

        Hashtable<String, Object> hb = new Hashtable<String, Object>();

        hb.put("1", "Java");

        hb.put("flag", true);

        hb.put("age", 44);

        Iterator iterator = hb.keySet().iterator();

        iterator.forEachRemaining(value -> System.out.println(hb.get(value)));  //使用了lamda

    }

}