java中的Collection集合类

随着1998年JDK 1.2的发布，同时新增了常用的Collections集合类，包含了Collection和Map接口。而Dictionary类是在1996年JDK 1.0发布时就已经有了。它们都可以在rt.jar这个基础类库包中找到。全文以JDK8为例，尝试介绍Collections集合类的相关内容。

它们的关系如上图所示，标蓝的为抽象类，实线全箭头指的是extends（继承），虚线全箭头表示implement（实现），虚线半箭头依赖指的是这个类里面有依赖接口或者类的成员变量，比如HashSet类，继承AbstractSet抽象类，它里面又定义了HashMap的成员变量：

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    private transient HashMap<E,Object> map;

    ...
}

一、Collection接口下的List和Set

首先Collection接口继承Iterable接口，主要定义了size、isEmpty、contains、toArray、add、remove、clear、equals、hashCode等方法

List接口继承Collection接口，新增了sort、get、set、indexof、lastindexof、subList等方法，Set接口也继承Collection接口，但没有List这些新增方法

先从语义上看，List表达列表的意思，Set表示集合的意思。两者区别在于：List元素有序、不唯一，Set元素无序、唯一。

List

List接口下有LinkedList、ArrayList、Vector实现类：

LinkedList在JDK1.7之后，从单向链表结构Entry变成了双向链表节点Node数据结构实现的，一个Node节点有前后节点，JDK源码如下（为节省篇幅，去掉了相关注释，挑了重点的成员变量和成员函数，后同）

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    transient int size = 0;
    transient Node<E> first;
    transient Node<E> last;

    private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
    ...
}

ArrayList和Vector使用变长数组实现的，但ArrayList非线程安全，达到数组长度时每次扩大50%：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final int DEFAULT_CAPACITY = 10;
    transient Object[] elementData; // non-private to simplify nested class access

    private int size;
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            ? 0 : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
        }

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

    ...
}

代码稍长，主要看add增加元素时调用ensureCapacityInternal，最后进入grow方法里

int newCapacity = oldCapacity + (oldCapacity >> 1);

这里newCapacity就是oldCapacity的1.5倍，再往下判断一下是否仍比传过来的新的长度minCapacity小（1增长到2时出现），再往下与最大整型Integer.MAX_VALUE相比进行处理，ArrayList数组最长也只能是Integer.MAX_VALUE。

Vector线程安全，达到数组长度时每次扩大一倍。除了public函数全部用synchronized修饰外，与ArrayList主要的不同的就是grow函数

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

可以看到，如果我们没有定义capacityIncrement 增长步长的话，newCapacity就是oldCapacity+oldCapacity，就是原数组长度的两倍。

ArrayList和Vector每次插入元素都需要System.arraycopy或Arrays.copyOf一次，每次数组长度不足时就要扩长一次。所以，网上通常的说法是：

1. ArratList主要消耗在扩大数组长度和每次的copy上，随机插入删除的效率较低，但查询速度较快；

2. Vector由于线程安全效率更低，插入删除查询都比较慢；

3. LinkedList由于每个Node只知道前后Node，所以随机查询效率较低，每次都需要从first或last开始遍历查询，但插入删除效率较高，只需改变引用；

事实真的是这样吗？实际测试过才知道。

import java.util.*;

public class Main {

    public static void main(String[] args) {
        List arrayList = new ArrayList();
        Long start_time = System.currentTimeMillis();
        for(int i = 0; i < 50000; i++){
            arrayList.add(0,i);
        }
        Long end_time = System.currentTimeMillis();
        System.out.println("ArrayList add time " + (end_time - start_time));

        List linkedList = new LinkedList();
        start_time = System.currentTimeMillis();
        for(int i = 0; i < 50000; i++){
            linkedList.add(0,i);
        }
        end_time = System.currentTimeMillis();
        System.out.println("LinkedList add time " + (end_time - start_time));

        start_time = System.currentTimeMillis();
        for(int i = 0; i < 50000; i++){
            arrayList.get(i);
        }
        end_time = System.currentTimeMillis();
        System.out.println("ArrayList get time " + (end_time - start_time));

        start_time = System.currentTimeMillis();
        for(int i = 0; i < 50000; i++){
            linkedList.get(i);
        }
        end_time = System.currentTimeMillis();
        System.out.println("LinkedList get time " + (end_time - start_time));
    }
}

ArrayList add time 281
LinkedList add time 0
ArrayList get time 16
LinkedList get time 1500

以上是网上一般的测试例子。我们看结果确实是这样的，ArrayList比LinkedList插入慢，比LinkedList查询快。但是这里我有一个疑问，为什么要使用add(index,element)方法呢？而不直接用我们常用的add(element)方法？如果换成add(element)又是怎样的呢？

import java.util.*;

public class Main {

    public static void main(String[] args) {
        List arrayList = new ArrayList();
        Long start_time = System.currentTimeMillis();
        for(int i = 0; i < 50000; i++){
            arrayList.add(i);
        }
        Long end_time = System.currentTimeMillis();
        System.out.println("ArrayList add time " + (end_time - start_time));

        List linkedList = new LinkedList();
        start_time = System.currentTimeMillis();
        for(int i = 0; i < 50000; i++){
            linkedList.add(i);
        }
        end_time = System.currentTimeMillis();
        System.out.println("LinkedList add time " + (end_time - start_time));
    }
}

ArrayList add time 0
LinkedList add time 16

换成add(element)的时候，ArrayList比LinkedList快，那么ArrayList的add(index,element)是什么处理逻辑呢？我们再来看看ArrayList里的源码：

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

可以看到，add(index,element)比add(e)主要多了System.arraycopy一句，这句的意思是把elementData数组在index下标后面的元素全部后移一位，我们例子里index是0，那么就是每次新增元素时，都要使eletmentData[0]后面的元素后移一位，然后把新元素放到eletmentData[0]上。

再来看看LinkedList的源码

    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index));
    }

    ...

    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

可以看到，主要性能消耗是linkBefore(element, node(index))这句node(index)，需要从first元素或者last元素（index与size相比，看index是在数组前半部分还是后半部分）找到特定index的node，拿到了这个node，修改前后元素的引用，修改引用消耗不大。所以如果index越靠近双向链表的中间，Linked的消耗越大。

这就很流氓了！add(0,element)是把ArrayList最坏的情况跟LinkedList最好的情况比较。我们回过头来看网上的说法，强调的是随机，那么我们再试试随机插入：

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Random random = new Random();
        List arrayList = new ArrayList();
        Long start_time = System.currentTimeMillis();
        for(int i = 0; i < 50000; i++){
            arrayList.add((arrayList.size() > 0) ? random.nextInt(arrayList.size()) : i, i);
        }
        Long end_time = System.currentTimeMillis();
        System.out.println("ArrayList add time " + (end_time - start_time));

        List linkedList = new LinkedList();
        start_time = System.currentTimeMillis();
        for(int i = 0; i < 50000; i++){
            linkedList.add((linkedList.size() > 0) ? random.nextInt(linkedList.size()) : i,i);
        }
        end_time = System.currentTimeMillis();
        System.out.println("LinkedList add time " + (end_time - start_time));
}

ArrayList add time 141
LinkedList add time 4187

以上例子按照ArrayList和LinkedList现有长度随机一个index去插入，我执行了多次，实际效果都是ArrayList比LinkedList快。

所以我的结论是：如果必须使用add(0,element)的时候，那就请使用LinkedList吧。

Set

Set下面主要有HashMap和TreeMap，先看看HashMap的源码

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    private transient HashMap<E,Object> map;

    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();

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

    ...
}

可以看到，HashSet实际就是利用HashMap存放元素的，将元素放入HashMap的Key里，利用HashMap的Key自动哈希散列来保证元素的唯一性，后面再详细聊聊HashMap如何进行存取元素的。

TreeSet目前没使用过，就先不说。后面研究过再补上。简要的理解是，TreeSet利用TreeMap实现，元素是有序的，和HashSet一样元素是唯一的。

回到上面所说的，List元素有序、不唯一，Set元素无序、唯一。唯一性大家应该能够理解，有序无序的意思是，LinkedList、ArrayList可以预知和控制元素排序，但HashSet根据元素哈希值存放的，不能根据插入的先后顺序控制。但这句话其实也是有问题的，因为TreeSet是有序的，估计因为不常用被忽略了吧。HashSet元素无序例子如下

import java.util.*;

public class Main {

    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        Random random = new Random();
        for(int i = 0; i < 10; i++){
            int r = random.nextInt(10000);
            System.out.print(r + " ");
            hashSet.add(r);
        }
        System.out.println("\n" + hashSet);
    }
}

6192 4913 4415 6384 6593 1136 8666 2021 7117 8972
[6192, 6384, 1136, 4913, 6593, 2021, 8666, 8972, 7117, 4415]

二、Map接口下的HashMap和HashTable

Map接口主要定义了自身是Entry<key, value>这种键值对数据结构，包含size、isEmpty、containsKey、containsValue、get、put、remove、clear、keySet等方法。

Map接口下有AbstractMap抽象类，AbstractMap实现了部分方法，增加了SimpleEntry<key, value>数据结构

AbstractMap下面有HashMap、TreeMap、WeakHashMap这几个实现类。

而HashTable是继承Dictionary的和实现Map接口的。

先来看HashMap的源码：

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {

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

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    transient Node<K,V>[] table;

    transient Set<Map.Entry<K,V>> entrySet;

    transient int size;

    final float loadFactor;

    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

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

    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)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;
    }

    public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
    }

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

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        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;
    }

    public boolean containsValue(Object value) {
        Node<K,V>[] tab; V v;
        if ((tab = table) != null && size > 0) {
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }

    ...
}

HashMap实现的复杂度跟前面的类不可同日而语，首先定义了一个静态的内部类Node，Node实现Map接口里的Entry<key, value>接口，并定义了hash变量和指向下一个Node的next变量，所以Node可以是一个单向链表，接着HashMap定义了Node<K,V>[] table 数组用来存放元素。首先看我们常用的存放元素函数put，它主要调用了putVal方法，概要的逻辑是：

1.判断初始化

2.利用元素的哈希值hash与(table长度-1)进行与&运算，得到新元素应该放在table数组的index下标

3.判断是否table数组index下标已经有值，有值则说明产生了碰撞，把新元素放在这个单向列表后端（深度最大为8，超过深度则转变成红黑树）

4.在获取table数组index下标的node时，和遍历单向链表时，如果发现key和已有的旧元素一致，则返回旧元素的值，不改变旧元素

5.判断是否需要扩容

这个putVal方法的详细逻辑是这样的：

if ((tab = table) == null || (n = tab.length) == 0)
    n = (tab = resize()).length;

↑ 第一个if判断table和长度是否为空，为空就初始化扩容，顺便赋了值。

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);

↑ 第二个if使用元素的哈希值hash与(table长度-1)进行与&运算，得到一个index，如果这个tab[index]没有值，就直接把新的这个元素放到tab[index]上

if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
    e = p;

↑ 如果上面tab[index]上已经有值了，说明多个key的哈希值和(table长度-1)与运算的结果一样，产生了碰撞，需要把这个key放到这个tab[index]上p的单向链表上。else里第一个if判断原来tab[index]元素的hash与新元素的hash是否一样，如果它们的hash一样，那么判断key是不是一样的，如果连key也一样，那么保留为旧元素。

else if (p instanceof TreeNode)
    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

↑ 第二个else if判断tab[index]上的p节点是否是红黑树TreeNode

else {
    for (int binCount = 0; ; ++binCount) {
        if ((e = p.next) == null) {
            p.next = newNode(hash, key, value, null);
            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;
    }
}

↑ 这个第二层else表示如果不是TreeNode，则是单向链表节点，那么会进入这里，遍历这个单向链表，这里的第一个if判断单向链表tab[index]上的p的next是否为空，为空就直接p.next指向新元素，TREEIFY_THRESHOLD定义深度最大为8，如果达到最大深度，就把这个单向链表转换成红黑树TreeNode，break退出遍历。第二个if判断如果这个单向链表tab[index]上的p不为空，那么如果p的key和新元素的key一样，那么保留为旧元素，break退出遍历。最后如果p.next不为空，Key又不一致，那么p = e继续往下遍历。

if (e != null) { // existing mapping for key
    V oldValue = e.value;
    if (!onlyIfAbsent || oldValue == null)
        e.value = value;
    afterNodeAccess(e);
    return oldValue;
}

↑ 外层else最后这个if判断之前是否取出了相同hash和key的node节点，如果有已存在这样的node，就把旧node的value值返回。

++modCount;
if (++size > threshold)
    resize();
afterNodeInsertion(evict);
return null;

↑ 函数最后就是判断是否要扩容了。

扩容resize函数也值得研究一下，因为元素hash值与数组长度-1与运算的，一旦数组长度发送改变，那么按道理，原有元素的数组位置应该会发送改变，甚至单向链表、红黑树里的元素都会涉及重新调整位置。这部分后面研究过再写。

接着，我们来分析一下get方法，这个方法主要调用了getNode方法，我们知道了put是怎么把元素放到对应的位置的，那么getNode的时候就相应的把这个位置找到，就可以获取元素了：

1.根据key的hash值与table数组长度-1做与运算，获得数组下标index

2.判断是否和table[index]的元素的key一致，一致就返回

3.判断table[index]上是否是红黑树，是红黑树则去红黑树找这个元素

4.判断table[index]是一个单向链表，遍历单向链表找到这个元素

这个逻辑比putVal简单很多，就不详细一段一段代码分析了。

接下来看看HashTable，虽说HashTable实现了Map接口，但是这个类其实在JDK1.0就已经有了，应该只是后来重现实现了而已。

HashTable继承Dictionary抽象类，Dictionary与Map很相似，我的感觉是Dictionary是古老的Map，为了兼容以前的代码，HashTable才仍然继承Dictionary的，毕竟可能很多面向抽象编程这么定义：Dictionary hashTable = new HashTable();

先来看看HashTable的源码：

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

    private transient Entry<?,?>[] table;

    private transient int count;

    private int threshold;

    private float loadFactor;

    private transient int modCount = 0;

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

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

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

    private static class Entry<K,V> implements Map.Entry<K,V> {
        final int hash;
        final 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;
        }

        @SuppressWarnings("unchecked")
        protected Object clone() {
            return new Entry<>(hash, key, value,
                                  (next==null ? null : (Entry<K,V>) next.clone()));
        }

        // Map.Entry Ops

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

        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;

            return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
               (value==null ? e.getValue()==null : value.equals(e.getValue()));
        }

        public int hashCode() {
            return hash ^ Objects.hashCode(value);
        }

        public String toString() {
            return key.toString()+"="+value.toString();
        }
    }

    ...
}

可以看到HashTable与HashMap很类似，HashTable的内部类Entry<key,value>也是实现Map的Entry<key,value>接口，也有一个hash成员变量和指向下一个Entry的next成员变量，也是一个单向链表。不同的在于，HashTable的public函数都用synchronized修饰，是线程安全的。

先来看看put函数，我们可以看到，重要的获取元素的数组下标Index的方式与HashMap有区别

index = (hash & 0x7FFFFFFF) % tab.length;

HashTable是这样处理的，0x7FFFFFFF的作用是，如果hash值是负数的话就把它变成正数，然后直接除数组长度tab.length取余，这样既保证index是正数，又保证比数组长度小。另外我们还可以看到，HashTable在put的时候产生碰撞时，并不会产生红黑树的处理。碰撞的时候先检查是否已有的key，如果遍历tab[index]单向链表里都没有，就把新的元素加在原来tab[index]上的元素的前面，tab[index]上就指向了新元素，新元素的next指向原来的元素。HashTable的单向链表没有深度控制。

get函数同样根据hash值找到index，遍历单向链表，找到元素。

TreeMap和WeakHashMap

TreeMap和WeakHashMap我也没有使用过，TreeMap和HashMap的区别主要特定是元素是有序的。WeakHashMap涉及弱引用，待了解后再补充吧。

由于本人知识水平有限，如有遗留错误之处请指正。