首先我们来看看Map的框架图 
Map是（Key-Value）键值对映射的抽象接口；AbstractMap实现了Map中的大部分方法接口，减少了Map的实现类的重复编码；SortMap为有序的键值对的映射接口；NavigableMap是继承于SortedMap的，支持搜索元素的接口。 HashMap、Hashtable、TreeMap、WeakHashMap为Map的实现类。 HashMap是基于拉链法实现的散列表（链表+数组），一般用于单线程中； Hashtable基于拉链法实现的散列表（链表+数组），一般用于多线程； WeakHashMap基于拉链法实现的散列表（（链表+数组）），一般用于单线程中。 TreeMap是有序的散列表（链表+数组），是通过红黑树实现的。一般用于单线程中。
HashMap与Hashtable的相同点 HashMap和Hashtable底层都是散列表（链表+数组），并且都是采用拉链法来实现的。 存储的思想：通过table数组存储，数组的每一个元素都是一个Entry，而每一个Entry都是一个单向链表，Entry链表中的每一个节点就保存了key-value键值对数据。 添加元素时，首先根据key值计算出哈希值，再计算出数组索引，然后根据数组索引找到Entry（单向链表），再遍历单向链表，将key和链表中的每一个节点的key进行对比。若key已经存在Entry链表中，则用该value值取代之前的value值；若key不在Entry链表中，则新建一个key-value节点，并将该节点插入Entry链表的表头位置。 删除元素时，首先根据key值计算出哈希值，再计算出数组索引，然后根据索引展出Entry（单向链表），若节点key-value存在于链表Entry中，则删除链表中的节点。 HashMap与Hashtable的相同点 1、继承和实现方式不同 HashMap继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。 Hashtable继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口 区别在于HashMap继承了AbstractMap,而Hashtable继承了Dictionary。下面简单讲解： Dictionary是一个抽象类，它直接继承于Object类，没有实现任何接口。Dictionary类是JDK1.0时引入的，尽管支持add（）、get（）、size（）等方法，但其API没有Map多。Dictionary一般是通过Enumeration（枚举类）去遍历，Map则是通过Iterator（迭代器）去遍历。然而，由于Hashtable也实现了Map接口。因此枚举类遍历和迭代遍历都可以。 AbstractMap为一个抽象类，它实现了Map接口的绝大部分API方法。 2、线程安全不同 Hashtable是同步的，即是线程安全的，一般用于多线程环境下。 HashMap是非同步的，即不是线程安全的，若要在多线程中使用HashMap，需要进行的额外的同步处理，比如使用synchronizedMap静态方法，或者使用java.util.concurrent包里的ConcurrentHashMap。 3、对null值的处理不同 HashMap的key、value都可以为。 Hashtable的key、value都不可以为null。 注意两者添加元素的方法： HashMap添加元素
// 将“key-value”添加到HashMap中public V put(K key, V value) { // 若“key为null”，则将该键值对添加到table[0]中。 if (key == null) return putForNullKey(value); // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。 int hash = hash(key.hashCode()); int i = indexFor(hash, table.length); for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！ if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordaccess(this); return oldValue; } } // 若“该key”对应的键值对不存在，则将“key-value”添加到table中 modCount++; addEntry(hash, key, value, i); return null;}// putForNullKey()的作用是将“key为null”键值对添加到table[0]位置PRivate V putForNullKey(V value) { for (Entry<K,V> e = table[0]; e != null; e = e.next) { if (e.key == null) { V oldValue = e.value; e.value = value; // recordAccess()函数什么也没有做 e.recordAccess(this); return oldValue; } } // 添加第1个“key为null”的元素都table中的时候，会执行到这里。 // 它的作用是将“设置table[0]的key为null，值为value”。 modCount++; addEntry(0, null, value, 0); return null;}Hashtable添加元素
// 将“key-value”添加到Hashtable中public synchronized V put(K key, V value) { // Hashtable中不能插入value为null的元素！！！ if (value == null) { throw new NullPointerException(); } // 若“Hashtable中已存在键为key的键值对”， // 则用“新的value”替换“旧的value” Entry tab[] = table; // Hashtable中不能插入key为null的元素！！！ // 否则，下面的语句会抛出异常！ int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { V old = e.value; e.value = value; return old; } } // 若“Hashtable中不存在键为key的键值对”， // (01) 将“修改统计数”+1 modCount++; // (02) 若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子) // 则调整Hashtable的大小 if (count >= threshold) { // Rehash the table if the threshold is exceeded rehash(); tab = table; index = (hash & 0x7FFFFFFF) % tab.length; } // (03) 将“Hashtable中index”位置的Entry(链表)保存到e中 Entry<K,V> e = tab[index]; // (04) 创建“新的Entry节点”，并将“新的Entry”插入“Hashtable的index位置”，并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。 tab[index] = new Entry<K,V>(hash, key, value, e); // (05) 将“Hashtable的实际容量”+1 count++; return null;}由上述代码可以得到： Hashtable的key和value值都不允许为空，否则会抛出空异常； HashMap的key和value值可以为空，当HashMap的key为null时，HashMap会将其固定的插入到table[0]的位置，当有多个key为null时，table[0]会保留最后插入的value，对前面的值进行覆盖。 4、支持的遍历种类不同 HashMap只支持迭代器（Iterator）遍历； HashtablezhichEnumeration（枚举类）和Iterator（迭代器）两种方式遍历。 5、通过Iterator迭代器遍历时，遍历的顺序不同 HashMap是从前向后的遍历数组，再对数组具体某一项对应的链表，从表头开始遍历。 Hashtable是从前向后遍历数组，再对数组具体，某一项对应的链表，从表头开始进行遍历。 HashMap的实现方式
// 返回“HashMap的Entry集合”public Set<Map.Entry<K,V>> entrySet() { return entrySet0();}// 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象private Set<Map.Entry<K,V>> entrySet0() { Set<Map.Entry<K,V>> es = entrySet; return es != null ? es : (entrySet = new EntrySet());}// EntrySet对应的集合// EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。private final class EntrySet extends AbstractSet<Map.Entry<K,V>> { ... public Iterator<Map.Entry<K,V>> iterator() { return newEntryIterator(); } ...}// 返回一个“entry迭代器”Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator();}// Entry的迭代器private final class EntryIterator extends HashIterator<Map.Entry<K,V>> { public Map.Entry<K,V> next() { return nextEntry(); }}private abstract class HashIterator<E> implements Iterator<E> { // 下一个元素 Entry<K,V> next; // expectedModCount用于实现fail-fast机制。 int expectedModCount; // 当前索引 int index; // 当前元素 Entry<K,V> current; HashIterator() { expectedModCount = modCount; if (size > 0) { // advance to first entry Entry[] t = table; // 将next指向table中第一个不为null的元素。 // 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。 while (index < t.length && (next = t[index++]) == null) ; } } public final boolean hasNext() { return next != null; } // 获取下一个元素 final Entry<K,V> nextEntry() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); Entry<K,V> e = next; if (e == null) throw new NoSuchElementException(); // 注意！！！ // 一个Entry就是一个单向链表 // 若该Entry的下一个节点不为空，就将next指向下一个节点; // 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。 if ((next = e.next) == null) { Entry[] t = table; while (index < t.length && (next = t[index++]) == null) ; } current = e; return e; } ...}Hashtable的实现方式
public Set<Map.Entry<K,V>> entrySet() { if (entrySet==null) entrySet = Collections.synchronizedSet(new EntrySet(), this); return entrySet;}private class EntrySet extends AbstractSet<Map.Entry<K,V>> { public Iterator<Map.Entry<K,V>> iterator() { return getIterator(ENTRIES); } ...}private class Enumerator<T> implements Enumeration<T>, Iterator<T> { // 指向Hashtable的table Entry[] table = Hashtable.this.table; // Hashtable的总的大小 int index = table.length; Entry<K,V> entry = null; Entry<K,V> lastReturned = null; int type; // Enumerator是 “迭代器(Iterator)” 还是 “枚举类(Enumeration)”的标志 // iterator为true，表示它是迭代器；否则，是枚举类。 boolean iterator; // 在将Enumerator当作迭代器使用时会用到，用来实现fail-fast机制。 protected int expectedModCount = modCount; Enumerator(int type, boolean iterator) { this.type = type; this.iterator = iterator; } // 从遍历table的数组的末尾向前查找，直到找到不为null的Entry。 public boolean hasMoreElements() { Entry<K,V> e = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (e == null && i > 0) { e = t[--i]; } entry = e; index = i; return e != null; } // 获取下一个元素 // 注意：从hasMoreElements() 和nextElement() 可以看出“Hashtable的elements()遍历方式” // 首先，从后向前的遍历table数组。table数组的每个节点都是一个单向链表(Entry)。 // 然后，依次向后遍历单向链表Entry。 public T nextElement() { Entry<K,V> et = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (et == null && i > 0) { et = t[--i]; } entry = et; index = i; if (et != null) { Entry<K,V> e = lastReturned = entry; entry = e.next; return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e); } throw new NoSuchElementException("Hashtable Enumerator"); } // 迭代器Iterator的判断是否存在下一个元素 // 实际上，它是调用的hasMoreElements() public boolean hasNext() { return hasMoreElements(); } // 迭代器获取下一个元素 // 实际上，它是调用的nextElement() public T next() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); return nextElement(); } ...}6、容量的初始值和增加方式不同 HashMap默认的容量大小是16，增加容量时，原始容量的两倍； Hashtable默认的容量大小是11；增加容量时，原始容量的2倍加1。 HashMap和Hashtable默认的加载因子0.75. 7、添加Key-Value时的hash值算法不同 HashMap添加元素时，是使用自定义的哈希算法。 Hashtable没有自定义哈希算法，而直接采用key的hashCode（）。 HashMap添加元素时，是使用自定义的哈希算法。
static int hash(int h) { h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4);}// 将“key-value”添加到HashMap中public V put(K key, V value) { // 若“key为null”，则将该键值对添加到table[0]中。 if (key == null) return putForNullKey(value); // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。 int hash = hash(key.hashCode()); int i = indexFor(hash, table.length); for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！ if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } // 若“该key”对应的键值对不存在，则将“key-value”添加到table中 modCount++; addEntry(hash, key, value, i); return null;}Hashtable没有自定义哈希算法，而直接采用的key的hashCode()。
public synchronized V put(K key, V value) { // Hashtable中不能插入value为null的元素！！！ if (value == null) { throw new NullPointerException(); } // 若“Hashtable中已存在键为key的键值对”， // 则用“新的value”替换“旧的value” Entry tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { V old = e.value; e.value = value; return old; } } // 若“Hashtable中不存在键为key的键值对”， // (01) 将“修改统计数”+1 modCount++; // (02) 若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子) // 则调整Hashtable的大小 if (count >= threshold) { // Rehash the table if the threshold is exceeded rehash(); tab = table; index = (hash & 0x7FFFFFFF) % tab.length; } // (03) 将“Hashtable中index”位置的Entry(链表)保存到e中 Entry<K,V> e = tab[index]; // (04) 创建“新的Entry节点”，并将“新的Entry”插入“Hashtable的index位置”，并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。 tab[index] = new Entry<K,V>(hash, key, value, e); // (05) 将“Hashtable的实际容量”+1 count++; return null;}8、两者部分API不同 HashMap不支持contains(Object value)方法，没有重写toString()方法； 而Hashtable支持contains(Object value)方法，而且重写了toString()方法。 补充：两者使用场景总结 根据上述总结的特点，一般单线程环境下，使用HashMap；而多线程环境爱下，使用HashTable,当然，多线程环境下，也可以使用ConcurrentHashMap。
HashMap和WeakHashMap的相同点 HashMap和WeakHashMap底层都是散列表(链表+数组)，存储的是key-value键值对；都继承于AbstractMap，实现Map接口；都包括四个构造函数，且参数一样；默认的初始容量都是16，默认的加载因子都是0.75；两者key和value都允许为null。 两者都是非同步的，即不是线程安全的。 HashMap和WeakHashMap的不同点 1、HashMap实现了Cloneable和Serializable接口， 而WeakHashMap没有。 HashMap实现Cloneable，意味着它能通过clone()克隆自己。 HashMap实现Serializable，意味着它支持序列化，能通过序列化去传输。 2、HashMap的键是强引用，而WeakHashMap的键是弱引用。 WeakReference的“弱键”能实现WeakReference对“键值对”的动态回收。当“弱键”不再被使用到时，GC会回收它，WeakReference也会将“弱键”对应的键值对删除。
文章只是作为自己的学习笔记，借鉴了网上的许多案例，如果觉得阔以的话，希望多交流，在此谢过…
新闻热点
疑难解答
