HashSet，HashTable，HashMap 源码分析（基于API 29 JDK8）

HashTable

HashTable 散列表，基于key和value，先看构造函数：

public class Hashtable
    extends Dictionary
    implements Map, Cloneable, java.io.Serializable {
    private transient HashtableEntry[] table;
    private transient int count;
    private int threshold;
    private float loadFactor;
    private transient int modCount = 0;
    public Hashtable(int initialCapacity, float loadFactor) {
        // initialCapacity初始容量，默认为11
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        // loadFactor加载因子，默认为0.75
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal Load: "+loadFactor);

        if (initialCapacity==0)
            initialCapacity = 1;
        this.loadFactor = loadFactor;
        table = new HashtableEntry[initialCapacity];
        // Android-changed: Ignore loadFactor when calculating threshold from initialCapacity
        // threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        // 阈值
        threshold = (int)Math.min(initialCapacity, MAX_ARRAY_SIZE + 1);
    }
    public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
    }
    public Hashtable() {
        this(11, 0.75f);
    }
    public Hashtable(Map t) {
        this(Math.max(2*t.size(), 11), 0.75f);
        putAll(t);
    }
}

Hashtable继承于Dictionary并实现了Map接口，接口中都是abstract函数，在此便不去细看，先分析Hashtable的构造函数，构造函数中创建了一个HashtableEntry数组，查看其源码：

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

HashtableEntry中保存了一个hash值，一个key一个value以及一个HashtableEntry的对象，回到Hashtable，从put/get开始看起，查看源码：

    public synchronized V put(K key, V value) {
        // Make sure the value is not null
        // Hashtable的value值不能为null
        if (value == null) {
            throw new NullPointerException();
        }

        // Makes sure the key is not already in the hashtable.
        HashtableEntry tab[] = table;
        // 计算key的hashCode值
        int hash = key.hashCode();
        // index由key的value值与上0x7FFFFFFF，并以tab的长度求余
        int index = (hash & 0x7FFFFFFF) % tab.length;
        @SuppressWarnings("unchecked")
        // 拿到HashtableEntry数组上的一个index
        HashtableEntry entry = (HashtableEntry)tab[index];
        // entry.hash是key的hash值
        for(; entry != null ; entry = entry.next) {
            // 新的key的hash值和 index位置的key值和hash值相等，则替换value
            if ((entry.hash == hash) && entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }
        // 添加一个HashtableEntry
        addEntry(hash, key, value, index);
        return null;
    }
    // hash是key.hashCode
    private void addEntry(int hash, K key, V value, int index) {
        // 操作次数+1
        modCount++;

        HashtableEntry tab[] = table;
        // 如果table的大小大于阈值
        if (count >= threshold) {
            // 扩容并建立新表
            rehash();

            tab = table;
            // 这里为什么要重新获取一次key的hash值
            hash = key.hashCode();
            // 获取index
            index = (hash & 0x7FFFFFFF) % tab.length;
        }

        // Creates the new entry.
        @SuppressWarnings("unchecked")
        // e是index位置的头指针
        HashtableEntry e = (HashtableEntry) tab[index];
        // 替换tab[index]为新的HashtableEntry，其next指针指向e（旧的头指针）
        tab[index] = new HashtableEntry<>(hash, key, value, e);
        // 容量+1
        count++;
    }

    protected void rehash() {
        // 旧容量
        int oldCapacity = table.length;
        HashtableEntry[] oldMap = table;

        // overflow-conscious code
        // 新容量为旧容量右移一位+1，即2倍
        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;
        }
        // 建立一个newCapacity大小的HashtableEntry数组
        HashtableEntry[] newMap = new HashtableEntry[newCapacity];
        // 操作数+1
        modCount++;
        // 阈值为容量*扩容因子
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
        // table指向空的newMap
        table = newMap;
        // 遍历旧的HashtableEntry数组并赋值
        for (int i = oldCapacity ; i-- > 0 ;) {
            // 将位置为i的HashtableEntry取出并赋值为newMap的index位置头指针
            for (HashtableEntry old = (HashtableEntry)oldMap[i] ; old != null ; ) {
                HashtableEntry e = old;
                old = old.next;

                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = (HashtableEntry)newMap[index];
                newMap[index] = e;
            }
        }
    }

    public synchronized V get(Object key) {
        // 获取HashtableEntry数组
        HashtableEntry tab[] = table;
        // 获取key的hash值
        int hash = key.hashCode();
        // 得到index
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (HashtableEntry e = tab[index] ; e != null ; e = e.next) {
            // 遍历index位置的链表，找到一个hash值以及key值相等的HashtableEntry对象，并返回其value值
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
        return null;
    }

下面做一个小结：
1、Hashtable通过保存HashtableEntry数组来保存一个包含key和value的对象。
2、HashtableEntry是一个单链表，通过hash碰撞，如果HashtableEntry[index]位置已经有数据了，新的key-value会以链表头的形式添加到链表中。
3、Hashtable有一个初始容量和扩容因子，当size>=loadFactor的时候，进行扩容，扩容会形成新的hash表。
知道其构成，Hashtable的remove/contains等函数心中大概有个底，如果感兴趣，可以自行查看其源码。

HashMap

HashMap也是基于哈希表，通过key-value对来存储/查询数据的，上面的Hashtable在api29的源码上一共1432行，而HashMap则由2391行，下面看源码，两者之间有什么异同。

public class HashMap extends AbstractMap
    implements Map, Cloneable, Serializable {
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    static final int MAXIMUM_CAPACITY = 1 << 30;
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    static final int TREEIFY_THRESHOLD = 8;
    static final int UNTREEIFY_THRESHOLD = 6;
    static final int MIN_TREEIFY_CAPACITY = 64;
    transient Node[] table;
    transient Set> entrySet;
    transient int size;
    transient int modCount;
    int threshold;
    final float loadFactor;
    public HashMap() {
        // 初始化负载因子为默认负载因子0.75f
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
    public HashMap(int initialCapacity) {
        // 以initialCapacity，默认负载因子创建HashMap
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        // 这里如果没有设置负载因子直接视作0.75f
        this.loadFactor = loadFactor;
        // 这个函数就很有意思了，取最高位为第K位，右移得到2^(K+1)-1，最终返回threshold为2^(K+1)
        // threshold的定义是下一次调整的容量大小
        this.threshold = tableSizeFor(initialCapacity);
    }
    public HashMap(Map m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }
    static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }

    //插入一个静态内部类，一条单链表
    static class Node implements Map.Entry {
        final int hash;
        final K key;
        V value;
        Node next;
        // 这里和HashTable是一样的，一个Node对象包含了key.hash，Key，value，以及一个next指针
        Node(int hash, K key, V value, Node next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
        ...
    }

这里插入一段讲解，关于关键字-transient。
1、transient修饰的变量不能被序列化。
2、transient只作用于实现 Serializable 接口（自定义序列化Externalizable中transient可以被序列化）。
3、transient只能用来修饰普通成员变量字段。
4、有没有 transient 修饰，静态变量都不能被序列化。
HashMap继承于AbstractMap，同样也实现Map，Cloneable，Serializable 接口，AbstractMap同样实现了Map接口，可以作为一个基类看待。
和HashTable一样找到put/get函数，查看源码：

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    static final int hash(Object key) {
        int h;
        // hash值右移16位并执行异或，可以降低碰撞
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node[] tab; Node p; int n, i;
        // 这里假设第一次put，于是table为null，resize()之后 n = 16
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 在i = (n - 1) & hash 的位置是否有值，如果没有，在i新建一个newNode对象
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            // 复杂的开始了，如果这个位置已经有一个对象了，这个对象还可能很长
            Node e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                // e = tab[i]
                e = p;
            else if (p instanceof TreeNode)
                // 红黑树的判断
                e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
            else {
                // 这里遍历链表
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        // 新建一个Node对象，并接到链表的尾端
                        p.next = newNode(hash, key, value, null);
                        // 如果，链表的长度>=8
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            // 先看这个函数
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

    final Node[] resize() {
        // 第一次put执行到这里的时候，table=null
        Node[] oldTab = table;
        // oldCap  = 0
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // threshold为2^(K+1)大小，这里初始化的时候没有给值，oldThr=0
        int oldThr = threshold;
        int newCap, newThr = 0;
        // 空构造的第一次put直接走else分值
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            // 初始化容量大小为16
            newCap = DEFAULT_INITIAL_CAPACITY;
            // 扩容阈值为16*0.75=12
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        // 将新阈值赋值给threshold 
        threshold = newThr;
        // 建立一个newCap大小的Node数组，并将table指向新的数组
        @SuppressWarnings({"rawtypes","unchecked"})
            Node[] newTab = (Node[])new Node[newCap];
        table = newTab;
        // 如果旧的table是有数据的，即不是初始化状态
        if (oldTab != null) {
            // 对oldTab进行遍历，oldCap为原始容量
            for (int j = 0; j < oldCap; ++j) {
                Node e;
                // 定义Node e为oldTab[j]，假设e不为null
                if ((e = oldTab[j]) != null) {
                    // 将oldTab[j]置null，之后就是e为头的链表/TreeNode
                    oldTab[j] = null;
                    if (e.next == null)
                        // e后面没有新的Node，那么直接以e.hash & (newCap - 1)作为index，为新的Node数组赋值
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        // 如果当前节点是红黑树节点，拆分树，如果size小的话则取消树
                        ((TreeNode)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        //loHead用户存储低位（位置不变）key的链头，loTail用于指向链尾位置。
                        Node loHead = null, loTail = null;
                        //hiHead用户存储即将存储在高位的key的链头，hiTail用于指向链尾位置。
                        Node hiHead = null, hiTail = null;
                        Node next;
                        do {
                            next = e.next;
                            //与原数组长度(2^K)相与后，得到的结果为0的，意味着在新数组中的位置(0-(2^K-1))是不变的，因此，将其组成一个链条
                            if ((e.hash & oldCap) == 0) {
                                // 如果尾指针为null，将e置为头指针
                                // 否则将e接在尾指针后面并将尾指针指向e
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                // 和上面的区别只有e.hash & oldCap!=0
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        // 如果是低位，那么链表在新Node数组的位置和原来一样
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        // 如果是在高位，则链表在新Node数组偏移了oldCap的位置
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        // 返回新数组
        return newTab;
    }

    final void treeifyBin(Node[] tab, int hash) {
        int n, index; Node e;
        // tab长度小于64，执行扩容
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            // index是hash与n-1碰撞的位置，e为链表头节点
            TreeNode hd = null, tl = null;
            // 这个循环的内容就是将单链表相互连接，形成一个TreeNode双链表
            do {
                TreeNode p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

    /*Forms tree of the nodes linked from this node*/
    /*从一个tree的节点构建红黑树*/
    final void treeify(Node[] tab) {
        TreeNode root = null;
        // 这里x=上个函数的hd，即双链表的表头，下面这个循环是用来构建红黑树的
        for (TreeNode x = this, next; x != null; x = next) {
            next = (TreeNode)x.next;
            x.left = x.right = null;
            // 如果root没有初始化，将root赋值为表头
            if (root == null) {
                x.parent = null;
                x.red = false;
                root = x;
            }
            else {
                K k = x.key;
                int h = x.hash;
                Class kc = null;
                for (TreeNode p = root;;) {
                    int dir, ph;
                    K pk = p.key;
                    if ((ph = p.hash) > h)
                        dir = -1;
                    else if (ph < h)
                        dir = 1;
                    else if ((kc == null &&
                            (kc = comparableClassFor(k)) == null) ||
                            (dir = compareComparables(kc, k, pk)) == 0)
                        dir = tieBreakOrder(k, pk);

                    TreeNode xp = p;
                    if ((p = (dir <= 0) ? p.left : p.right) == null) {
                        x.parent = xp;
                        if (dir <= 0)
                            xp.left = x;
                        else
                            xp.right = x;
                        root = balanceInsertion(root, x);
                        break;
                    }
                }
            }
        }
        moveRootToFront(tab, root);
    }

    public V get(Object key) {
        Node e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    final Node getNode(int hash, Object key) {
        Node[] tab; Node first, e; int n; K k;
        // tab不为空，tab长度大于0，(n - 1) & hash位置不为空
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            // 如果first就是要找的值，直接返回
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            // first之后有内容
            if ((e = first.next) != null) {
                // first是红黑树的头结点
                if (first instanceof TreeNode)
                    return ((TreeNode)first).getTreeNode(hash, key);
                // 遍历链表找值
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

HashTable和HashMap的区别：
1.HashTable发生hash碰撞的时候链表是头插法，而HashMap则采用尾插法。
2.HashTable在达到阈值进行扩容，新的index = (e.hash & 0x7FFFFFFF) % newCapacity，而HashMap则是通过判断e.hash & oldCap==0 ? 原位置:原位置+扩容值。
3.HashTable的函数带了synchronized，是线程安全的，HashMap的线程安全类可以参考ConcurrentHashMap（这个下次分析）。
4.HashTable的getIterator是使用的Enumerator，没有对modCount进行检查，而HashMap的Iterator是fail-fast迭代器，如果被其他线程改变结构（增加或者移除元素）会抛出ConcurrentModificationException。
5.HashMap不能保证元素次序不变。

HashSet

emmm，可怜的HashSet只有353行，和前面一样，先看构造函数：

public class HashSet
    extends AbstractSet
    implements Set, Cloneable, java.io.Serializable
{
    private transient HashMap map;
    private static final Object PRESENT = new Object();
    public HashSet() {
        map = new HashMap<>();
    }
    public HashSet(Collection c) {
        map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
        addAll(c);
    }
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap<>(initialCapacity, loadFactor);
    }
    public HashSet(int initialCapacity) {
        map = new HashMap<>(initialCapacity);
    }
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }
    ...
}

这初始化就初始化了个hashmap是我没想到的，这也没什么好分析的，默认大小16，可以设置扩容因子。看add/remove，找找为什么它不能重复的原因。

    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }

真是省事，add的值作为key，push到hashmap一个Object对象PRESENT，hashmap的key值是唯一的，如果这里位置原来没有值，那么返回true，如果已经有值了，返回PRESENT==null，false。