public Hashtable() {

        this(11, 0.75f);

    }

    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;

        this.loadFactor = loadFactor;

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

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

    }

    通过学习hashmap知道，这表示hashtable初始是11的大小，也是0.75的容量比例

    table = new Entry<?,?>[initialCapacity]; 说明初始时已经构建了数据结构是Entry类型的数组，Entry源码和hashmap基本元素用的node基本是一样的

    threshold= 11*0.75=8.25 即容量是8

    threshold上限是MAX_ARRAY_SIZE + 1     Integer.MAX_VALUE - 8+1=Integer.MAX_VALUE -7   这个上限根据注释说明，是因为一些JVM的不同限制，为了防止OutOfMemoryError而进行-8的

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

        // Make sure the value is not null

        if (value == null) {

            throw new NullPointerException();

        }

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

        Entry<?,?> tab[] = table;

        int hash = key.hashCode();

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

        @SuppressWarnings("unchecked")

        Entry<K,V> entry = (Entry<K,V>)tab[index];

        for(; entry != null ; entry = entry.next) {

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

                V old = entry.value;

                entry.value = value;

                return old;

            }

        }

        addEntry(hash, key, value, index);

        return null;

    }

    1.synchronized 同步  还是方法级别的同步，因此效率可想肯定不是很高

    2.value==null 抛错  说明值不能null

    3.int index = (hash & 0x7FFFFFFF) % tab.length;   这个index的算法，看逼格就没hashmap高啊

        3.1具体0x7FFFFFFF是2 31次幂，即01111111111111111111111111111111   安位与 随便一个与之后好像没变化啊，那这句是干嘛的呢，闲的？我们要相信大佬们不会闲的没事写废代码的

            与的作用其实就是第一位0，为了干掉负的hash的，-1的hash值就是-1，再%，显然不能让出现这个情况

        3.2    %tab.length就好说了，让索引落在table内，这种方式相比hashmap的二次hash再异或，效率肯定差一些的

    4.for循环  只看这个循环就知道了，数据结构是数组加链表了

        主要作用是找当前索引的链表上有没有相同key  又就覆盖值结束

    5.addEntry(hash, key, value, index);当前索引没找到相同key，或者压根索引上就是空的，就在当前索引上加节点

private void addEntry(int hash, K key, V value, int index) {

        modCount++;

        Entry<?,?> tab[] = table;

        if (count >= threshold) {

            // Rehash the table if the threshold is exceeded

            rehash();

            tab = table;

            hash = key.hashCode();

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

        }

        // Creates the new entry.

        @SuppressWarnings("unchecked")

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

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

        count++;

    }

    1. modCount++;结构变更次数，不谈

    2. if (count >= threshold) {  是否扩容的判断，也是一个主要地方了，看看扩容方案

        2.1 rehash();

        protected void rehash() {

            int oldCapacity = table.length;

            Entry<?,?>[] oldMap = table;

            // overflow-conscious code

            int newCapacity = (oldCapacity << 1) + 1;    说明扩容方案是 扩2倍+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;

                }

            }

        }

        2.2 完成扩容了，需要对本次要添加元素重新计算索引位置

    3.     Entry<K,V> e = (Entry<K,V>) tab[index];

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

        创建新元素把添加到数组。

        这里有一个地方要注意到，再有值的情况下，hashmap是在链表末尾挂载新元素的，而这是在链表头也就是数组索引这个位置挂载新元素，一前一后要注意这点