Java集合-Hashtable源码解析-JDK1.8

/**     * 保村数据的数组     */    private transient Entry<?, ?>[] table;
    /**     * 数组的元素数量     */    private transient int count;
    /**     * 扩容阈值     *     * @serial     */    private int threshold;
    /**     * 加载因子     */    private float loadFactor;
    /**     * 被修改的次数     */    private transient int modCount = 0;
    /**     * use serialVersionUID from JDK 1.0.2 for interoperability     */    private static final long serialVersionUID = 1421746759512286392L;    /**     *最大容量     */    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private static class Entry<K, V> implements Map.Entry<K, V> {        final int hash;        final K key;        V value;        Hashtable.Entry<K, V> next;
        protected Entry(int hash, K key, V value, Hashtable.Entry<K, V> next) {            this.hash = hash;            this.key = key;            this.value = value;            this.next = next;        }    }

 /**     * 指定初始容量和加载因子     */    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);    }
    /**     * 指定初始容量，加载因子使用默认的0.75     */    public Hashtable(int initialCapacity) {        this(initialCapacity, 0.75f);    }
    /**     * 默认构造方法     */    public Hashtable() {        this(11, 0.75f);    }
    /**     * 添加一个map     */    public Hashtable(Map<? extends K, ? extends V> t) {        this(Math.max(2 * t.size(), 11), 0.75f);        putAll(t);    }

/**     * 添加方法     */    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;        //计算key的哈希值        int hash = key.hashCode();        //计算key应该放的索引        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;    }     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            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++;    }

  /**     * 扩容方法     */    @SuppressWarnings("unchecked")    protected void rehash() {        int oldCapacity = table.length;        Entry<?, ?>[] oldMap = table;
        // 尝试扩容2倍再+1        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;            }        }    }

  /**     * 查找方法     */    @SuppressWarnings("unchecked")    public synchronized V get(Object key) {        Entry<?, ?> tab[] = table;        //计算哈希        int hash = key.hashCode();        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;        //计算hash        int hash = key.hashCode();        int index = (hash & 0x7FFFFFFF) % tab.length;        @SuppressWarnings("unchecked")        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;    }