public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable 

    /**
     * The hash table data.
     */
    private transient HashtableEntry<?,?>[] table;

    //HashTable条目数总量
    private transient int count;

    //下次扩容量
    private int threshold;

    //负载因子
    private float loadFactor;

    //修改次数
    private transient int modCount = 0;

    //默认的构造函数
    public Hashtable() {
        this(11, 0.75f);
    }
    //指定容量大小
    public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
    }
     //指定容量大小和负载因子大小
    public Hashtable(int initialCapacity, float loadFactor) {
        //指定的容量大小不可以小于0,否则将抛出IllegalArgumentException异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        ////指定的负载因子不可以小于0或为Null，若判定成立则抛出IllegalArgumentException异常
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal Load: "+loadFactor);
       //若指定的容量大小为0,则赋为1 即容量初始大小最小为 1
        if (initialCapacity==0)
            initialCapacity = 1;
        this.loadFactor = loadFactor;
        //声明table实例
        table = new HashtableEntry<?,?>[initialCapacity];
        //下次扩容量长度
        threshold = (int)Math.min(initialCapacity, MAX_ARRAY_SIZE + 1);
    }
     //传入一个Map集合,将Map集合中元素Map.Entry全部添加进HashTable实例中
    public Hashtable(Map<? extends K, ? extends V> t) {
        this(Math.max(2*t.size(), 11), 0.75f);
        putAll(t);
    }

private static class HashtableEntry<K,V> implements Map.Entry<K,V> {
    // END Android-changed: Renamed Entry -> HashtableEntry.
        final int hash;
        final K key;
        V value;
        HashtableEntry<K,V> next;
         //构造函数
        protected HashtableEntry(int hash, K key, V value, HashtableEntry<K,V> next) {
            this.hash = hash;
            this.key =  key;
            this.value = value;
            this.next = next;
        }

        @SuppressWarnings("unchecked")
        protected Object clone() {
            return new HashtableEntry<>(hash, key, value,
                                  (next==null ? null : (HashtableEntry<K,V>) next.clone()));
        }

        // Map.Entry Ops
         //获取key
        public K getKey() {
            return key;
        }
         //获取value
        public V getValue() {
            return value;
        }
        //设置value
        public V setValue(V value) {
            if (value == null)
                throw new NullPointerException();

            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }
         //equals对比
        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;

            return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
               (value==null ? e.getValue()==null : value.equals(e.getValue()));
        }
        //获取hash值
        public int hashCode() {
            return hash ^ Objects.hashCode(value);
        }

        public String toString() {
            return key.toString()+"="+value.toString();
        }
    }

 //这里使用Synchronized锁方法的方式来保证put方法的在多线程下的数据安全
public synchronized V put(K key, V value) {
        // 确定value值不可为null
        if (value == null) {
            throw new NullPointerException();
        }

        // 确定key已经在table中存在 
        HashtableEntry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        HashtableEntry<K,V> entry = (HashtableEntry<K,V>)tab[index];
        //通过for循环,查找符合条件的key，赋予新的Value
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }
        //添加新的Entry
        addEntry(hash, key, value, index);
        return null;
    }
private void addEntry(int hash, K key, V value, int index) {
        //修改次数+1
        modCount++;

        HashtableEntry<?,?> tab[] = table;
        //如果HashTable的子条目大小 大于 下次扩容大小
        if (count >= threshold) {
            // 如果超过阈值，则重新组织HashTable 即对HashTable进行扩容
            rehash();

            tab = table;
            hash = key.hashCode();
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // Creates the new entry.
        @SuppressWarnings("unchecked")
        //将tab中索引位置下的Entry赋予 e
        HashtableEntry<K,V> e = (HashtableEntry<K,V>) tab[index];
        //创建新的HashtableEntry赋予tab中索引位置
        tab[index] = new HashtableEntry<>(hash, key, value, e);
        //table的条目树+1
        count++;
    }