Hashtable源码浅读

/**
* Hashtable继承于Dictionary类，且实现了Map接口
*
*/
public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable {
 
    /**
     * 定义内部存储数据的Entry数组。
     */
    private transient Entry[] table;
 
    /**
     * 定义table中的实际entry数。
     */
    private transient int count;
 
    /**
     * 定义一个界限值，如果count超过这个界限值，则rehash。
     * threshold = (int)(capacity * loadFactor)
     */
    private int threshold;
 
    /**
     * 定义负载系数。
     */
    private float loadFactor;
 
    /**
     * 定义modCount表示此Hashtable结构上变化的次数，结构上的变化是指
     * 改变Hashtable的内部entry数量或者执行了rehash操作。
     */
    private transient int modCount = 0;
 
    /** 序列化ID */
    private static final long serialVersionUID = 1421746759512286392L;
 
    /**
     * 根据指定的initialCapacity和loadFactor来创建一个新的空的hashtable。
     */
    public Hashtable(int initialCapacity, float loadFactor) {
    // 如果initialCapacity小于0，则抛出IllegalArgumentException异常。
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        // 如果loadFactor小于0或者loadFactor是NaN（Not a Number），抛出IllegalArgumentException异常。
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal Load: "+loadFactor);
        // 如果传入的initialFacor是0，则将其赋值为1.
        if (initialCapacity==0)
            initialCapacity = 1;
    this.loadFactor = loadFactor
    // 创建长度为initialCapacity的Entry数组。
    table = new Entry[initialCapacity];
    // 将initialCapacity * loadFactor的值赋给threshold。
    threshold = (int)(initialCapacity * loadFactor);
    }
 
    /**
     * 根据给定的initialCapacity创建一个新的空的hashtable，
     * loadFactor没有传入，所以取默认值0.75。
     */
    public Hashtable(int initialCapacity) {
    this(initialCapacity, 0.75f);
    }
 
    /**
     * Hashtable的不带参的构造函数，创建一个新的空的hashtable，
     * initialCapacity的默认值是11，threshold的默认值是0.75.
     */
    public Hashtable() {
    this(11, 0.75f);
    }
 
    /**
     * 根据传入的t来创建一个与t包含相同内容的hashtable，
     * threshold取默认值0.75.
     */
    public Hashtable(Map<? extends K, ? extends V> t) {
    // initialCapacity取2*t.size()和11中的较大值。
    this(Math.max(2*t.size(), 11), 0.75f);
    // 把t的数组都加到新创建的hashtable中。
    putAll(t);
    }
 
    /**
     * 返回hashtable中的key的数量。
     * 加锁。
     */
    public synchronized int size() {
    return count;
    }
 
    /**
     * 判断hashtable中是否有key。
     * 加锁。
     */
    public synchronized boolean isEmpty() {
    return count == 0;
    }
 
    /**
     * 返回所有key组成的枚举对象。
     * 加锁。
     */
    public synchronized Enumeration<K> keys() {
    return this.<K>getEnumeration(KEYS);
    }
 
    /**
     * 返回所有value组成的枚举对象。
     * 可以通过枚举的方法来依次遍历value值。
     * 加锁。
     */
    public synchronized Enumeration<V> elements() {
    return this.<V>getEnumeration(VALUES);
    }
 
    /**
     * 判断传入的value是否存在于hashtable中。
     * 加锁。
     */
    public synchronized boolean contains(Object value) {
    // 如果value为null，则抛出NullPointerException异常。
    if (value == null) {
        throw new NullPointerException();
    }
 
    Entry tab[] = table;
    // 遍历table，通过equals方法来判断value是否相等。
    for (int i = tab.length ; i-- > 0 ;) {
        for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) {
        if (e.value.equals(value)) {
            // 如果相等，则返回true。
            return true;
        }
        }
    }
    // 否则返回false。
    return false;
    }
 
    /**
     * 和contains(Object value)相同。
     * 未加锁。
     */
    public boolean containsValue(Object value) {
    return contains(value);
    }
 
    /**
     * 判断hashtable中是否包含有指定的key。
     * 加锁。
     */
    public synchronized boolean containsKey(Object key) {
    Entry tab[] = table;
    // 取得key的hashCode。
    int hash = key.hashCode();
    // 取得key在table数组中对应的下标。
    // hash & x7FFFFFFF可以防止hash是负数的情况。
    // 正数与0x7FFFFFFF进行&操作后不变，负数则变为正数。
    int index = (hash & 0x7FFFFFFF) % tab.length;
    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
        // 此处判断key是否相等有两个条件，分别是hashCode相等且equals也返回true。
        if ((e.hash == hash) && e.key.equals(key)) {
        return true;
        }
    }
    // 否则返回false。
    return false;
    }
 
    /**
     * 通过给定的key取value。
     * 加锁。
     */
    public synchronized V get(Object key) {
    Entry tab[] = table;
    // 取得key的hashCode。
    int hash = key.hashCode();
    // 取得key在table数组中对应的下标。
    int index = (hash & 0x7FFFFFFF) % tab.length;
    // 遍历此下标上的链表，判断是否存在相同key的值。
    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;
    }
 
    /**
     * 对table数组进行扩容。此方法在key的数量超过界限值时会自动被调用。
     */
    protected void rehash() {
    // 获取扩容前的数组长度。
    int oldCapacity = table.length;
    Entry[] oldMap = table;
 
    // 定义新的容量，为旧容量的2倍加上1.
    int newCapacity = oldCapacity * 2 + 1;
    // 创建长度为newCapacity的新Entry数组。
    Entry[] newMap = new Entry[newCapacity];
 
    modCount++;
    // 重新计算新的界限值。
    threshold = (int)(newCapacity * loadFactor);
    table = newMap;
 
    // 从旧数组的最后一位开始向前遍历。
    for (int i = oldCapacity ; i-- > 0 ;) {
        // 遍历此下标上的链表并加入到新数组中。
        for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
        Entry<K,V> e = old;
        old = old.next;
 
        int index = (e.hash & 0x7FFFFFFF) % newCapacity;
        // 新的Entry插在数组下标上链表的第一位。
        e.next = newMap[index];
        newMap[index] = e;
        }
    }
    }
 
    /**
     * 向hashtable中添加元素。
     * 加锁。 
     */
    public synchronized V put(K key, V value) {
    // Make sure the value is not null
    // 如果value为null，则抛出NullPointerException异常。
    if (value == null) {
        throw new NullPointerException();
    }
 
    // Makes sure the key is not already in the hashtable.
    // 判断hashtable中是否已存在key。
    Entry tab[] = table;
    // 此处看出key也不可以是null，否则也会抛出NullPointerException异常。
    int hash = key.hashCode();
    // 获取key对应在数组中的下标。
    int index = (hash & 0x7FFFFFFF) % tab.length;
    // 遍历此下标上的链表，判断是否已存在key，如果存在则覆盖value值，并返回旧值。
    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
        V old = e.value;
        e.value = value;
        return old;
        }
    }
 
    // 如果不存在，则要添加新的Entry，hashtable的结构发生改变，modCount自增。
    modCount++;
    // 如果count大于或者等于界限值，则执行refresh()方法来扩容。
    if (count >= threshold) {
        // Rehash the table if the threshold is exceeded
        rehash();
 
            tab = table;
            // 扩容完成后，再取得此key对应在新数组中的下标。
            index = (hash & 0x7FFFFFFF) % tab.length;
    }
 
    // Creates the new entry.
    // 创建新的Entry，并把它添加到链表的第一位。
    Entry<K,V> e = tab[index];
    tab[index] = new Entry<K,V>(hash, key, value, e);
    count++;
    // 创建成功则返回null。
    return null;
    }
 
    /**
     * 从hashtable中删除给定的key对应的Entry。
     * 加锁。
     */
    public synchronized V remove(Object key) {
    Entry tab[] = table;
    int hash = key.hashCode();
    // 获取key在数组中对应的下标。
    int index = (hash & 0x7FFFFFFF) % tab.length;
    // 遍历下标上的链表。
    for (Entry<K,V> e = tab[index], prev = null ; e != null ; prev = e, e = e.next) {
        // 判断key是否相等。
        if ((e.hash == hash) && e.key.equals(key)) {
        // 如果相等，则执行删除操作，结构发生改变，modCount自增。
        modCount++;
        // 如果被删除的不是该链表的第一位，则将前面Entry的next属性指向后面Entry，跳过此
        // 将被删除的Entry。
        if (prev != null) {
            prev.next = e.next;
        } else {
            // 如果被删除的是链表的第一位，则将后一位Entry赋值给此下标上的值。
            tab[index] = e.next;
        }
        count--;
        V oldValue = e.value;
        // 将value设为null，等待垃圾回收。
        e.value = null;
        // 返回被删除的Entry（value已为null）。
        return oldValue;
        }
    }
    // 如果hashtable中不存在此key，则直接返回null。
    return null;
    }
 
    /**
     * 将给定的Map类型的t里所有的Entry添加到当前hashtable中，如果key有重复则会被覆盖。
     * 加锁。
     */
    public synchronized void putAll(Map<? extends K, ? extends V> t) {
        for (Map.Entry<? extends K, ? extends V> e : t.entrySet())
            put(e.getKey(), e.getValue());
    }
 
    /**
     * 清空此hashtable中的数组。
     */
    public synchronized void clear() {
    Entry tab[] = table;
    // 结构发生改变，modCount自增。
    modCount++;
    for (int index = tab.length; --index >= 0; )
        tab[index] = null;
    count = 0;
    }
 
    /**
     * 浅层复制一份hashtable。
     * 加锁。
     */
    public synchronized Object clone() {
    try {
        Hashtable<K,V> t = (Hashtable<K,V>) super.clone();
        t.table = new Entry[table.length];
        // 因为Entry实现了自己的clone方法，所以需要调用。
        for (int i = table.length ; i-- > 0 ; ) {
        t.table[i] = (table[i] != null)
            ? (Entry<K,V>) 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();
    }
    }
 
    /**
     * 实现自己的toString方法。
     * 加锁。
     */
    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();
            // 这里做了"key == this"的判断，应该是为了防止死循环。
            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值，返回对应的枚举对象。
     * 如果count为0，则直接返回枚举类的空实现。
     */
    private <T> Enumeration<T> getEnumeration(int type) {
    if (count == 0) {
        return (Enumeration<T>)emptyEnumerator;
    } else {
        return new Enumerator<T>(type, false);
    }
    }
    /**
     * 根据传入的type值，返回对应的迭代器对象。
     * 如果count为0，则直接返回迭代器的空实现。
     */
    private <T> Iterator<T> getIterator(int type) {
    if (count == 0) {
        return (Iterator<T>) emptyIterator;
    } else {
        return new Enumerator<T>(type, true);
    }
    }
 
    // Views
 
    /**
     * 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 = null;
    private transient volatile Set<Map.Entry<K,V>> entrySet = null;
    private transient volatile Collection<V> values = null;
 
    /**
     * 返回由hashtable中所有key组成的线程安全的Set。
     * 对于hashtable的任何修改将会反映到此Set中，反之亦然。
     */
    public Set<K> keySet() {
    if (keySet == null)
        keySet = Collections.synchronizedSet(new KeySet(), this);
    return keySet;
    }
 
    /**
     * 定义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();
        }
    }
 
    /**
     * 返回线程安全的entrySet。
     *
     * @since 1.2
     */
    public Set<Map.Entry<K,V>> entrySet() {
    if (entrySet==null)
        entrySet = Collections.synchronizedSet(new EntrySet(), this);
    return entrySet;
    }
 
    private class EntrySet extends AbstractSet<Map.Entry<K,V>> {
        public Iterator<Map.Entry<K,V>> iterator() {
        return getIterator(ENTRIES);
        }
 
    public boolean add(Map.Entry<K,V> o) {
        return super.add(o);
    }
 
        public boolean contains(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry entry = (Map.Entry)o;
            Object key = entry.getKey();
            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.equals(entry))
                    return true;
            return false;
        }
 
        public boolean remove(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
        K key = entry.getKey();
            Entry[] tab = table;
            int hash = key.hashCode();
            int index = (hash & 0x7FFFFFFF) % tab.length;
 
            for (Entry<K,V> e = tab[index], prev = null; e != null;
                 prev = e, e = e.next) {
                if (e.hash==hash && e.equals(entry)) {
                    modCount++;
                    if (prev != null)
                        prev.next = e.next;
                    else
                        tab[index] = e.next;
 
                    count--;
                    e.value = null;
                    return true;
                }
            }
            return false;
        }
 
        public int size() {
            return count;
        }
 
        public void clear() {
            Hashtable.this.clear();
        }
    }
 
 
    // Comparison and hashing
 
    /**
     * equals方法。
     * 加锁。
     */
    public synchronized boolean equals(Object o) {
    // 如果o和this指向的是同一对象，则返回true。
    if (o == this)
        return true;
    //     如果o不是Map类型，则返回false。
    if (!(o instanceof Map))
        return false;
    Map<K,V> t = (Map<K,V>) o;
    // 如果o和this的size大小不一样，则返回false。
    if (t.size() != size())
        return false;
 
        // key和value的equals方法都为true的情况下才返回true。
        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;
    }
 
    /**
     * 取得hashCode值。
     * 加锁。
     */
    public synchronized int hashCode() {
        /*
         * 在此处，为了防止hashtable中key是自身而导致死循环的现象出现，
         * 用loadFactor作为guard来进行判断，可以避免死循环的发生。
         */
        int h = 0;
        if (count == 0 || loadFactor < 0)
            return h;  // Returns zero
 
        loadFactor = -loadFactor;  // Mark hashCode computation in progress
        Entry[] tab = table;
        for (int i = 0; i < tab.length; i++)
            for (Entry e = tab[i]; e != null; e = e.next)
                h += e.key.hashCode() ^ e.value.hashCode();
        loadFactor = -loadFactor;  // Mark hashCode computation complete
 
    return h;
    }
 
    /**
     * Hashtable内部数据结构Entry类。
     */
    private static class Entry<K,V> implements Map.Entry<K,V> {
    int hash;
    K key;
    V value;
    Entry<K,V> next;
 
    protected Entry(int hash, K key, V value, Entry<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
    /**
     * 自己实现clone方法，创建一个新的Entry，从数组上的那个Entry开始，
     * 这条链表上的所有Entry都会被clone。
     */
    protected Object clone() {
        return new Entry<K,V>(hash, key, value,
                  (next==null ? null : (Entry<K,V>) next.clone()));
    }
 
    // Map.Entry Ops
 
    public K getKey() {
        return key;
    }
 
    public V getValue() {
        return value;
    }
    /**
     * value依然不能为null。
     */
    public V setValue(V value) {
        if (value == null)
        throw new NullPointerException();
 
        V oldValue = this.value;
        this.value = value;
        return oldValue;
    }
 
    public boolean equals(Object o) {
        if (!(o instanceof Map.Entry))
        return false;
        Map.Entry e = (Map.Entry)o;
        // 在非null的情况下，只有key和value的equals方法都返回true的情况下才返回true。
        return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
           (value==null ? e.getValue()==null : value.equals(e.getValue()));
    }
 
    // 取得hashCode，通过对key和value的hashCode进行异或操作取得。
    public int hashCode() {
        return hash ^ (value==null ? 0 : value.hashCode());
    }
 
    public String toString() {
        return key.toString()+"="+value.toString();
    }
    }
 
    // Types of Enumerations/Iterations
    private static final int KEYS = 0;
    private static final int VALUES = 1;
    private static final int ENTRIES = 2;
 
    /**
     * 遍历hashtable用的类，此类实现了Enumeration和Iterator接口，
     * 既可以返回迭代器对象也可以返回枚举对象，由传入的参数iterator决定。
     */
    private class Enumerator<T> implements Enumeration<T>, Iterator<T> {
    Entry[] table = Hashtable.this.table;
    int index = table.length;
    Entry<K,V> entry = null;
    Entry<K,V> lastReturned = null;
    int type;
 
    /**
     * iterator为true的时候，表明返回迭代器对象而不是枚举对象。
     */
    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<K,V> 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;
    }
 
    public T nextElement() {
        Entry<K,V> 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<K,V> 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;
 
        for (Entry<K,V> e = tab[index], 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();
        }
    }
    }
 
 
    private static Enumeration emptyEnumerator = new EmptyEnumerator();
    private static Iterator emptyIterator = new EmptyIterator();
 
    /**
     * Hashtable的枚举对象的空实现。
     */
    private static class EmptyEnumerator implements Enumeration<Object> {
 
    EmptyEnumerator() {
    }
 
    public boolean hasMoreElements() {
        return false;
    }
 
    public Object nextElement() {
        throw new NoSuchElementException("Hashtable Enumerator");
    }
    }
 
 
    /**
     * Hashtable的迭代器的空对象的实现。
     */
    private static class EmptyIterator implements Iterator<Object> {
 
    EmptyIterator() {
    }
 
    public boolean hasNext() {
        return false;
    }
 
    public Object next() {
        throw new NoSuchElementException("Hashtable Iterator");
    }
 
    public void remove() {
        throw new IllegalStateException("Hashtable Iterator");
    }
 
    }
 
}