java中HashMap和HashTable的区别是什么？HashMap和HashTable的简单比较

public class HashMap<k> extends AbstractMap<k>
    implements Map<k>, Cloneable, Serializable</k></k></k>

public class Hashtable<k>
    extends Dictionary<k>
    implements Map<k>, Cloneable, java.io.Serializable</k></k></k>

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> entry = (Entry<k>)tab[index];
        for(; entry != null ; entry = entry.next) {
            if ((entry.hash == hash) &amp;&amp; entry.key.equals(key)) {
                V old = entry.value;
                entry.value = value;
                return old;
            }
        }

        addEntry(hash, key, value, index);
        return null;
    }</k></k>

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

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

        // overflow-conscious code
        int newCapacity = (oldCapacity  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;
		//从链表数组尾到头遍历
        for (int i = oldCapacity ; i-- > 0 ;) {
            for (Entry<k> old = (Entry<k>)oldMap[i] ; old != null ; ) {
                Entry<k> e = old;
                old = old.next;
				//从新定位链位置
                int index = (e.hash &amp; 0x7FFFFFFF) % newCapacity;
                e.next = (Entry<k>)newMap[index];
                newMap[index] = e;
            }
        }
    }</k></k></k></k>

final Node<k>[] resize() {
        Node<k>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        //如果远链表数组长度大于零
        if (oldCap &gt; 0) {
            //如果原长度大于或等于MAXIMUM_CAPACITY(2^30)，则将threshold(闸值)设为Integer.MAX_VALUE大约为MAXIMUM_CAPACITY(2^30)的二倍
            if (oldCap &gt;= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //让新的容量变为旧的二倍
            else if ((newCap = oldCap = DEFAULT_INITIAL_CAPACITY)
                 //新的闸值也变为原来的二倍
                newThr = oldThr  m)
        else if (oldThr &gt; 0) // initial capacity was placed in threshold
        	//让新的容量等于旧的闸值
            newCap = oldThr;
         //下面的else是默认的构造器，即public HashMap()
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //新的闸值为零时（也就是(newCap = oldCap = MAXIMUM_CAPACITY的情况），这时需要赋予newThr正确的值。
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;   //闸值=链表数组长度*加载因子。
            newThr = (newCap [] newTab = (Node<k>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            //遍历老的链表数组
            for (int j = 0; j  e;
                //当oldTab[j]这条链不为空时
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    //如果这条链只有首节点有数据，把它添加进新链表数组中
                    if (e.next == null)
                        //因为数组的容量时2的n次方，所以使用hash&amp;(newCap-1)来计算出在那条链中。
                        newTab[e.hash &amp; (newCap - 1)] = e;
                     //如果老的链在红黑树中，使用split()方法来复制
                    else if (e instanceof TreeNode)
                        ((TreeNode<k>)e).split(this, newTab, j, oldCap);
                    //当前链中不只只有一个链表头数据时，遍历链表来复制
                    else { // preserve order
                        //数据的复制有两种情况，第一种是原位置不变，第二种是位置改变
         				loHead代表和原链相同位置的链，hiHead代表是原链加上原容量的链，因为扩容后长度为原长度的二倍，一个链中的节点要不在原位置的链中，要么在原位置加原容量的链中
                        Node<k> loHead = null, loTail = null;
                        Node<k> hiHead = null, hiTail = null;
                        Node<k> next;
                        do {
                            next = e.next;
                            //通过e.hash和oldCap进行&amp;运算来得出位置是否需要改变。
                            比如原数组容量为16（10000）和hash值进行&amp;运算，如果高位1未参加运算，则为0即位置不变，如果高位参加了运算值不等于0,需要改变位置。
                           
                        
                            //loHead和hiHead分别代表原位置的链和新位置的链
                            if ((e.hash &amp; 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;
                            //原位置为j
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            //新位置为j+oldCap
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }</k></k></k></k></k></k></k>