HashMap和Hashtable的区别

HashMap

存放键值对，继承AbstractMap<K,V>类，实现了Map<K,V>, Cloneable, Serializable接口，jdk1.8之前底层结构是数组+链表，jdk1.8之后使用了数组+链表/红黑树

1. 非线程安全
2. 底层结构时Node数组
3. key可以为null ，但只有一个，value可以为null，且不限个数
4. 默认初始容量为16，每次扩充，容量变为原来的2倍，创建时如果给定了容量初始值，HashMap 会将其扩充为2的幂次方大小（HashMap 中的tableSizeFor()方法保证）。因此其容量大小总是2的幂次方大小．这么做的原因是：使 (n - 1) & hash等同于hash%n，且位运算效率比模运算高
5. JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当Hash冲突的链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间，使原来hash冲突链表的查找时间复杂度：O(n)减少为使用红黑树时的O(log(n))。
6. hash计算方式：(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
7. 数组下标计算方式：int index = (n - 1) & hash

问题：为什么HashMap中只能有一个为null的key?
HashMap中的hash计算方法为：

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

插入方法：

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

key=null，key对于的hash值都为0，使用tab[i = (n - 1) & hash]计算得到索引值为0，元素处于Node数组的第一个位置
当再插入一个key为null的元素时，hash值相同，得到相同的索引位置，然后判断key也相等都为null，这时就会把之前插入的元素替换掉．所有HashMap中只存在一个key=null的元素．

Hashtable

继承了Dictionary类，实现了Map<K,V>, Cloneable, java.io.Serializable接口

1. 线程安全的，几乎所有方法都使用了synchronized修饰
2. 底层结构是Entry数组
3. 不允许key或者value为null，value为空会直接抛出NPE，因为Hashtable中key的hash计算方法是直接调用Object中的hashCode()方法，所以key也不能为空
4. hash计算方法：key.hashCode()
5. 数组下标计算方法：(hash & 0x7FFFFFFF) % tab.length;
6. 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1：int newCapacity = (oldCapacity << 1) + 1;

未完待续．．．