Hashtable

Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable{}

---

这个类实现了一个键值哈希表，其中Key值对象的类要实现hashCode和equals方法。

哈希表有两个重要的参数：初始容量值(initial capacity )和装填因子（load factor），容量值是哈希表中桶（buckets）的数量，容量值默认值为11，装填因子默认值为0.75。哈希表解决哈希碰撞的方法：每个桶中存储多个实体，这些实体需要顺序搜索。当哈希表中的实体数量与容量的比值超过装填因子时，哈希表将自动扩容。

注意：哈希表的容量值一般为质数

装填因子设置为0.75是对时间和空间消费的折中选择。设置太高，则增加时间花费；设置太低，则浪费空间。当哈希表扩容时，需要对原有哈希表中的实体进行重新哈希，会有时间消耗，如果初始容量设置capacity=maxnum/loadfator，则可以避免哈希表扩容。初始容量不宜太大，否则会浪费空间，但是设置足够大总比不断扩容重哈希要好很多。

The iterators returned by the iterator method of the collections returned by all of this class’s “collection view methods” are fail-fast.

fail-fast机制：当Iterator操作时，集合中的元素发生结构性的改变（不是由于Iterator.remove方法引起的），Iterator就会抛出ConcurrentModificationException。在并发模式下，iterator会快速并且干净的失败，而不是在后面某个操作时具有任意的、具有冒险行为的、不确定的。Hashtable的枚举方法所返回的枚举对象不是fail-fast的。

fail-fast的行为不能得到保证，一般来说，在面对不同步的并发修改时是不可能做出任何保证的。itertaor的fail-fast应当只用于检测错误，而不是利用它使得程序的迭代行为运行正确。

Hashtable是同步的、线程安全的，如果程序不需要同步，可以使用HashMap代替。如果需要一个高并发的线程安全的类，则可以使用ConcurrentHashMap。

Hashtable的方法是加了synchronized关键词。

Hashtable成员变量

/*** The hash table data.* 使用Entry数组存储数据*/private transient Entry<?,?>[] table;/*** The total number of entries in the hash table.*/private transient int count;/*** The table is rehashed when its size exceeds this threshold.  (The* value of this field is (int)(capacity * loadFactor).)* *重新hash的阈值* @serial*/private int threshold;/*** The load factor for the hashtable.*装填因子* @serial*/private float loadFactor;/*** 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).* * Hashtable结构改变的次数，用于fail-fast机制*/private transient int modCount=0;/*** The maximum size of array to allocate.* Some VMs reserve some header words in an array.* Attempts to allocate larger arrays may result in* OutOfMemoryError: Requested array size exceeds VM limit* * 分配数组的最大值*/private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

Hashtable方法

/*** 构造函数，默认capacity=11,loadFactor=0.75;* threshold最大值为Integer.MAX_VALUE-8+1;*/public Hashtable(int initialCapacity, float loadFactor);public Hashtable(int initialCapacity);public Hashtable();/*** 注意是两倍的t.size()*/public Hashtable(Map<? extends K, ? extends V> t) {        this(Math.max(2*t.size(), 11), 0.75f);        putAll(t);    }public synchronized int size();public synchronized boolean isEmpty();public synchronized Enumeration<K> keys() {        return this.<K>getEnumeration(KEYS);    }public synchronized Enumeration<V> elements() {        return this.<V>getEnumeration(VALUES);/*** 对每个桶中的链表进行遍历，所以要用到两个for循环* 判断是否存在value值的键值对，比查找是否存在key值的键值对花费要高很多，因为key可以hash查找，而value只能挨个查找对比。*/public synchronized boolean contains(Object value) {        if (value == null) {            throw new NullPointerException();        }        Entry<?,?> tab[] = table;        for (int i = tab.length ; i-- > 0 ;) {            for (Entry<?,?> e = tab[i] ; e != null ; e = e.next) {                if (e.value.equals(value)) {                    return true;                }            }        }        return false;    }public boolean containsValue(Object value);public synchronized boolean containsKey(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 true;            }        }        return false;    } 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;    }/*** 以接近两倍的原有容量扩展。* newCapacity = oldCapacity << 1 + 1; 两倍加1，也就是尽可能避免选择能被2整除的数。最多也就是MAX_ARRAY_SIZE.* 在桶中链表插入的时候，插入在头部，头部也是存储有值的。*/protected void rehash() {        int oldCapacity = table.length;        Entry<?,?>[] oldMap = table;        // overflow-conscious code        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;                //看懂这一点，和C++中的指针不同，这里没有专门的头指针。                e.next = (Entry<K,V>)newMap[index];                newMap[index] = e;            }        }    }/***private函数，在后面几个方法中会调用。*添加一个Entry，Entry类将在稍后介绍*Entry成员变量包含有：hash,key,value,next。*/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++;    }/*** 如果Hashtable中有key值所对应的键值对，则更新key所对应的valu，否则创建并添加一个新的Entry。* key 和 value都不能为null。当key为null时，key.hashCode()抛异常，当value为null时，检查并抛异常。*/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;    }/***注意删除时，要有个保存前一个结点的位置，所以有个prev变量。另外还要注意，删除的是数组中的元素还是数组内链表的元素。**/public synchronized V remove(Object key) {        Entry<?,?> tab[] = table;        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;    } public synchronized void putAll;/***清除的时候要对数组内的每个对象进行清除。*/ public synchronized void clear() {        Entry<?,?> tab[] = table;        modCount++;        for (int index = tab.length; --index >= 0; )            tab[index] = null;        count = 0;    }/***注意这里是深拷贝。*请注意比浅拷贝和深拷贝的区别。*/public synchronized Object clone() {        try {            Hashtable<?,?> t = (Hashtable<?,?>)super.clone();            t.table = new Entry<?,?>[table.length];            for (int i = table.length ; i-- > 0 ; ) {                t.table[i] = (table[i] != null)                    ? (Entry<?,?>) table[i].clone() : null;            }            t.keySet = null;            t.entrySet = null;            t.values = null;            t.modCount = 0;            return t;        } catch (CloneNotSupportedException e) {            // this shouldn't happen, since we are Cloneable            throw new InternalError(e);        }    }/*** 注意String的连接操作尽量用StringBuilder.*/public synchronized String toString() {        int max = size() - 1;        if (max == -1)            return "{}";        StringBuilder sb = new StringBuilder();        Iterator<Map.Entry<K,V>> it = entrySet().iterator();        sb.append('{');        for (int i = 0; ; i++) {            Map.Entry<K,V> e = it.next();            K key = e.getKey();            V value = e.getValue();            sb.append(key   == this ? "(this Map)" : key.toString());            sb.append('=');            sb.append(value == this ? "(this Map)" : value.toString());            if (i == max)                return sb.append('}').toString();            sb.append(", ");        }    }/***type是用于区分返回的是key还是value的枚举*/ private <T> Enumeration<T> getEnumeration(int type) {        if (count == 0) {            return Collections.emptyEnumeration();        } else {            return new Enumerator<>(type, false);        }    }    private <T> Iterator<T> getIterator(int type) {        if (count == 0) {            return Collections.emptyIterator();        } else {            return new Enumerator<>(type, true);        }    }

/*** Each of these fields are initialized to contain an instance of the* appropriate view the first time this view is requested.  The views are* stateless, so there's no reason to create more than one of each.* 有且只有一份，每次访问的时候返回的都是同一份。*/private transient volatile Set<K> keySet;private transient volatile Set<Map.Entry<K,V>> entrySet;private transient volatile Collection<V> values;/**     * Returns a {@link Set} view of the keys contained in this map.     * The set is backed by the map, so changes to the map are     * reflected in the set, and vice-versa.  If the map is modified     * while an iteration over the set is in progress (except through     * the iterator's own <tt>remove</tt> operation), the results of     * the iteration are undefined.  The set supports element removal,     * which removes the corresponding mapping from the map, via the     * <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,     * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt>     * operations.  It does not support the <tt>add</tt> or <tt>addAll</tt>     * operations.     *     *对于keySet、entrySet、values、iterator等删除、清空操作是会改变Hashtable中的数据，Hashtable中的数据改变时，这些视图中的数据也会改变。     *这些视图对象都是现成同步的。     * @since 1.2     */    public Set<K> keySet() {        if (keySet == null)            keySet = Collections.synchronizedSet(new KeySet(), this);        return keySet;    }    private class KeySet extends AbstractSet<K> {        public Iterator<K> iterator() {            return getIterator(KEYS);        }        public int size() {            return count;        }        public boolean contains(Object o) {            return containsKey(o);        }        public boolean remove(Object o) {            return Hashtable.this.remove(o) != null;        }        public void clear() {            Hashtable.this.clear();        }    }

/*** equals方法三步：1，判断是否是自己；2，判断是否同一类型；3，判断内容是否相等。*/public synchronized boolean equals(Object o) {        if (o == this)            return true;        if (!(o instanceof Map))            return false;        Map<?,?> t = (Map<?,?>) o;        if (t.size() != size())            return false;        try {            Iterator<Map.Entry<K,V>> i = entrySet().iterator();            while (i.hasNext()) {                Map.Entry<K,V> e = i.next();                K key = e.getKey();                V value = e.getValue();                if (value == null) {                    if (!(t.get(key)==null && t.containsKey(key)))                        return false;                } else {                    if (!value.equals(t.get(key)))                        return false;                }            }        } catch (ClassCastException unused)   {            return false;        } catch (NullPointerException unused) {            return false;        }        return true;    }public synchronized int hashCode() {        /*         * This code detects the recursion caused by computing the hash code         * of a self-referential hash table and prevents the stack overflow         * that would otherwise result.  This allows certain 1.1-era         * applets with self-referential hash tables to work.  This code         * abuses the loadFactor field to do double-duty as a hashCode         * in progress flag, so as not to worsen the space performance.         * A negative load factor indicates that hash code computation is         * in progress.         */        int h = 0;        if (count == 0 || loadFactor < 0)            return h;  // Returns zero        loadFactor = -loadFactor;  // Mark hashCode computation in progress        Entry<?,?>[] tab = table;        for (Entry<?,?> entry : tab) {            while (entry != null) {                h += entry.hashCode();                entry = entry.next;            }        }        loadFactor = -loadFactor;  // Mark hashCode computation complete        return h;    }public synchronized V getOrDefault(Object key, V defaultValue) ;/*** 注意这里用到了modCount的值作为判断数据是否改动的依据。*/public synchronized void forEach(BiConsumer<? super K, ? super V> action) {        Objects.requireNonNull(action);     // explicit check required in case                                            // table is empty.        final int expectedModCount = modCount;        Entry<?, ?>[] tab = table;        for (Entry<?, ?> entry : tab) {            while (entry != null) {                action.accept((K)entry.key, (V)entry.value);                entry = entry.next;                if (expectedModCount != modCount) {                    throw new ConcurrentModificationException();                }            }        }    } public synchronized void replaceAll; public synchronized V putIfAbsent; public synchronized boolean remove;  ...太多了，不一一介绍了。

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

 private class Enumerator<T> implements Enumeration<T>, Iterator<T> {        Entry<?,?>[] table = Hashtable.this.table;        int index = table.length;        Entry<?,?> entry;        Entry<?,?> lastReturned;        int type;        /**         * Indicates whether this Enumerator is serving as an Iterator         * or an Enumeration.  (true -> Iterator).         */        boolean iterator;        /**         * The modCount value that the iterator believes that the backing         * Hashtable should have.  If this expectation is violated, the iterator         * has detected concurrent modification.         */        protected int expectedModCount = modCount;        Enumerator(int type, boolean iterator) {            this.type = type;            this.iterator = iterator;        }        public boolean hasMoreElements() {            Entry<?,?> e = entry;            int i = index;            Entry<?,?>[] t = table;            /* Use locals for faster loop iteration */            while (e == null && i > 0) {                e = t[--i];            }            entry = e;            index = i;            return e != null;        }        @SuppressWarnings("unchecked")        public T nextElement() {            Entry<?,?> et = entry;            int i = index;            Entry<?,?>[] t = table;            /* Use locals for faster loop iteration */            while (et == null && i > 0) {                et = t[--i];            }            entry = et;            index = i;            if (et != null) {                Entry<?,?> e = lastReturned = entry;                entry = e.next;                return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);            }            throw new NoSuchElementException("Hashtable Enumerator");        }        // Iterator methods        public boolean hasNext() {            return hasMoreElements();        }        public T next() {            if (modCount != expectedModCount)                throw new ConcurrentModificationException();            return nextElement();        }        public void remove() {            if (!iterator)                throw new UnsupportedOperationException();            if (lastReturned == null)                throw new IllegalStateException("Hashtable Enumerator");            if (modCount != expectedModCount)                throw new ConcurrentModificationException();            synchronized(Hashtable.this) {                Entry<?,?>[] tab = Hashtable.this.table;                int index = (lastReturned.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 == lastReturned) {                        modCount++;                        expectedModCount++;                        if (prev == null)                            tab[index] = e.next;                        else                            prev.next = e.next;                        count--;                        lastReturned = null;                        return;                    }                }                throw new ConcurrentModificationException();            }        }    }

Iterator,Set…等删除操作会影响到原有数据。Iterator在遍历的过程中，原有数据不能发生结构性的改变，否则抛出ConcurrentModificationException，但可以用自己的remove方法使原有数据发生改变。Enumeration没有这种限制，即使原有数据在Enumeration遍历时发生结构性的改变，Enumeration也不会抛出异常，但是遍历结果不太理想，无法把控。Iterator和Enumeration遍历的时候都是从数组的最后开始往前遍历的。

hash值的计算公式

(hashCode() & 0x7FFFFFFF)%Capacity

为什么要&上0x7FFFFFFF，因为要保证计算出来的值为正整数（32位），所以最高位要默认为0，防止溢出，表示是正整数。