《Java1.8源码分析》：HashTable

《Java1.8源码分析》：HashTable

继承结构

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

继承的是Dictionary类，实现了Map、Cloneable、Serializable。

注意：这也是Hashtable和HashMap第一个不同的地方，HashMap实现的是AbstractMap类。

属性

// 用来实现Hashtable所借助的数组,默认大小为11.(HashMap默认是16，且是2的幂次方)
1. private transient Entry<?,?>[] table;
//用来记录table数组中存储元素的个数
2. private transient int count;
//扩容的门限，即如果数组table中存储的元素个数大于threshold，则扩大数组table的大小
3. private int threshold;
//加载因子，默认值为0.75f,扩容门线threshold的值等于loadFactor与数组table的容量的乘积.
4. private float loadFactor;

构造函数

//hashTable有4个构造函数，但都是调用这个
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);
    }

put函数

//hashtable是安全的，每个方法都加了锁
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];
        //如果数组table中有值，则检查下是否有此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;
            }
        }

        addEntry(hash, key, value, index);
        return null;
    }

从源码中可以看到，put方法首先检查value是否为null，如果为空，则抛异常。

注意：这也是Hashtable与HashMap的另一个不同点，在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。

addEntry函数
给数组table的index位置添加元素。

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")
        //获取table数组在index的元素，如果非空，则新节点放在这个节点的前面，成为新的链表头
        Entry<K,V> e = (Entry<K,V>) tab[index];
        tab[index] = new Entry<>(hash, key, value, e);
        count++;
    }

思想：首先检查下数组table存储的元素个数是否大于扩容门限threshold.如果大于，则扩容，扩容之后，重新获取key的hashcode，并根据hashcode重新计算要存储的位置index.最后将要存储的数据存储到table[index]中。这里要注意的一点是，如果table[index]中已经有其它元素了，那么在同一个位子上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾

rehash函数
rehash方法的实现思想如下：首先对原来的长度乘以2+1就为即将扩容的长度。然后新建一个newCapacity的数组，将原来的table数组的元素拷贝到新的数组中去即可。

protected void rehash() {
        int oldCapacity = table.length;
        Entry<?,?>[] oldMap = table;

        // overflow-conscious code
        //扩容后数组为2*n+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;
        //将原数据拷贝到新hashTable中
        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;
            }
        }
    }

get函数

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;
    }

remove函数

public synchronized V remove(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        //先根据hash值找到数组
        Entry<K,V> e = (Entry<K,V>)tab[index];
        //遍历Entry，找到key
        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;
    }

小结
hashTable底层也是基于数组实现的，对外的每个方法都加了synchrronized进行同步。