Hashtable、HashMap、TreeMap有什么区别？

Map是java广义集合框架的另外一部分，其中HashMap又是使用频率最高的类型之一。所以HashMap本身和相关类型也是经常在面试中被提问。
一般可以回答的内容主要是基本特征、数据结构、HashMap的设计，其他可以问的问题可以更多，大多为HashMap的源码，hash算法等。
典型回答：

1. Hashtable、HashMap、TreeMap都实现了Map接口，使用键值对的形式存储数据和操作数据。
2. Hashtable是java早期提供的，方法是同步的（加了synchronized）。key和value都不能是null值。
3. HashMap的方法不是同步的，支持key和value为null的情况。行为上基本和Hashtable一致。由于Hashtable是同步的，性能开销比较大，一般不推荐使用Hashtable。通常会选择使用HashMap。
4. HashMap进行put和get操作，基本上可以达到常数时间的性能
5. TreeMap是基于红黑树的一种提供顺序访问的Map，和HashMap不同，它的get或put操作的时间复杂度是O(log(n))。具体的顺序由指定的Comparator来决定，或者根据键key的具体顺序来决定。

首先通过两张图来看下Map的相关关系：

Hashtable类似Vector和stack的早期相关集合,它继承了Dictionary。类结构上与HashMap有明显不同。

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

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

public class TreeMap<K,V> extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable {}

下面着重看下hashMap.
首先看下HashMap的构造函数：

//默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//默认构造函数，加载因子是默认值
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; 
}
//指定容量大小的构造函数
public HashMap(int initialCapacity) { }

// 指定“容量大小”和“加载因子”的构造函数
public HashMap(int initialCapacity, float loadFactor) { }

//包含“子Map”的构造函数
public HashMap(Map<? extends K, ? extends V> m) {}

首先从构造函数我们可以知道：

• 容量大小capacity
• 加载因子（负载系数/扩容因子）loadFactor

容量capacity就是哈希表的容量。HashMap的初始容量是16.

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

加载因子是指哈希表在其容量自动增加之前可以达到多少的一种尺度（threshold=capacity * load factor）。当哈希表的数量超过加载因子和容量的乘积时，则对哈希表进行resize操作。从而哈希表将具有大约两倍的桶数。

 //The next size value at which to resize (capacity * load factor).
int threshold;

下面我们再来看下HashMap的数据结构，HashMap可以看做是数组（Node<>[]）和链表的复合结构。数组被分为一个个桶（bucket）。通过哈希值决定了键值对在这个数组的寻址。如果出现hash值相同的键值对，则以链表形式存储。如果链表大小超过阀值（TREEIFY_THRESHOLD = 8）。链表就会改造成树形结构。如图：

我们再通过put值的代码看下数组和链表的储存。

public V put(K key, V value) {
//对key进行Hash
    return putVal(hash(key), key, value, false, true);
}
//java8里面的hash算法
static final int hash(Object key) {
    int h;
    //key的hashCode和移位操作后进行异或运算（这种处理就可以有效避免类似情况下的哈希碰撞）
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
   //node数组
   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;
        //如果hash值相同则放入链表
        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)
    //如果哈希表数量大于threshold则resize
        resize();
    afterNodeInsertion(evict);
    return null;
}

其中树化改造如下：

 final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    //如果数量小于64，直接扩容
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
        //如果大于，则进行树化
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> 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);
    }
}

那么HashMap为什么要树化呢？
本质上是个安全问题。因为在元素放置过程中，如果一个对象hash冲突，都会被放置到同一个桶中，则会形成一个链表。链表的查询是线性的，会严重影响存取的性能。

resize()的源码如下：

 final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    //容量
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //容量尺度/门限值
    int oldThr = threshold;
    int newCap, newThr = 0;
    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
        newCap = DEFAULT_INITIAL_CAPACITY;
        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 = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    //扩容后将老的数组中的元素放入新的数组
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}