Java--- HashMap Hashtable TreeMap的异同点

第1部分 Map概括

Map 是“键值对”映射的抽象接口。

AbstractMap 实现了Map中的绝大部分函数接口。它减少了“Map的实现类”的重复编码。

SortedMap 有序的“键值对”映射接口。

NavigableMap 是继承于SortedMap的，支持导航函数的接口。

HashMap, Hashtable, TreeMap, WeakHashMap这4个类是“键值对”映射的实现类。它们各有区别！

HashMap 是基于“拉链法”实现的散列表。一般用于单线程程序中。

Hashtable 也是基于“拉链法”实现的散列表。它一般用于多线程程序中。

WeakHashMap 也是基于“拉链法”实现的散列表，它一般也用于单线程程序中。相比HashMap，WeakHashMap中的键是“弱键”，当“弱键”被GC回收时，它对应的键值对也会被从WeakHashMap中删除；而HashMap中的键是强键。

TreeMap 是有序的散列表，它是通过红黑树实现的。它一般用于单线程中存储有序的映射。

第2部分 HashMap和Hashtable异同

第2.1部分 HashMap和Hashtable的相同点

HashMap和Hashtable都是存储“键值对(key-value)”的散列表，而且都是采用拉链法实现的。

存储的思想都是：通过table数组存储，数组的每一个元素都是一个Entry；而一个Entry就是一个单向链表，Entry链表中的每一个节点就保存了key-value键值对数据。

添加key-value键值对：首先，根据key值计算出哈希值，再计算出数组索引(即，该key-value在table中的索引)。然后，根据数组索引找到Entry(即，单向链表)，再遍历单向链表，将key和链表中的每一个节点的key进行对比。若key已经存在Entry链表中，则用该value值取代旧的value值；若key不存在Entry链表中，则新建一个key-value节点，并将该节点插入Entry链表的表头位置。

删除key-value键值对：删除键值对，相比于“添加键值对”来说，简单很多。首先，还是根据key计算出哈希值，再计算出数组索引(即，该key-value在table中的索引)。然后，根据索引找出Entry(即，单向链表)。若节点key-value存在与链表Entry中，则删除链表中的节点即可。

上面介绍了HashMap和Hashtable的相同点。正是由于它们都是散列表，我们关注更多的是“它们的区别，以及它们分别适合在什么情况下使用”。那接下来，我们先看看它们的区别。

第2.2部分 HashMap和Hashtable的不同点

1 继承和实现方式不同

HashMap 继承于AbstractMap，实现了Map、Cloneable、java.io.Serializable接口。

Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。

HashMap的定义:

public class HashMap<K,V>

extends AbstractMap<K,V>

implements Map<K,V>, Cloneable, Serializable { … }

Hashtable的定义:

public class Hashtable<K,V>

extends Dictionary<K,V>

implements Map<K,V>, Cloneable, java.io.Serializable { … }

从中，我们可以看出：

1.1 HashMap和Hashtable都实现了Map、Cloneable、java.io.Serializable接口。

实现了Map接口，意味着它们都支持key-value键值对操作。支持“添加key-value键值对”、“获取key”、“获取value”、“获取map大小”、“清空map”等基本的key-value键值对操作。

实现了Cloneable接口，意味着它能被克隆。

实现了java.io.Serializable接口，意味着它们支持序列化，能通过序列化去传输。

1.2 HashMap继承于AbstractMap，而Hashtable继承于Dictionary

Dictionary是一个抽象类，它直接继承于Object类，没有实现任何接口。Dictionary类是JDK 1.0的引入的。虽然Dictionary也支持“添加key-value键值对”、“获取value”、“获取大小”等基本操作，但它的API函数比Map少；而且 Dictionary一般是通过Enumeration(枚举类)去遍历，Map则是通过Iterator(迭代器)去遍历。 然而‘由于Hashtable也实现了Map接口，所以，它即支持Enumeration遍历，也支持Iterator遍历。关于这点，后面还会进一步说明。

AbstractMap是一个抽象类，它实现了Map接口的绝大部分API函数；为Map的具体实现类提供了极大的便利。它是JDK 1.2新增的类。

2 线程安全不同

Hashtable的几乎所有函数都是同步的，即它是线程安全的，支持多线程。

而HashMap的函数则是非同步的，它不是线程安全的。若要在多线程中使用HashMap，需要我们额外的进行同步处理。 对HashMap的同步处理可以使用Collections类提供的synchronizedMap静态方法，或者直接使用JDK 5.0之后提供的java.util.concurrent包里的ConcurrentHashMap类。

3 对null值的处理不同

HashMap的key、value都可以为null。

Hashtable的key、value都不可以为null。

我们先看看HashMap和Hashtable “添加key-value”的方法

HashMap的添加key-value的方法

1 // 将“key-value”添加到HashMap中

2 public V put(K key, V value) {

3 // 若“key为null”，则将该键值对添加到table[0]中。

4 if (key == null)

5 return putForNullKey(value);

6 // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。

7 int hash = hash(key.hashCode());

8 int i = indexFor(hash, table.length);

9 for (Entry<K,V> e = table[i]; e != null; e = e.next) {

10 Object k;

11 // 若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！

12 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {

13 V oldValue = e.value;

14 e.value = value;

15 e.recordAccess(this);

16 return oldValue;

17 }

18 }

19

20 // 若“该key”对应的键值对不存在，则将“key-value”添加到table中

21 modCount++;

22 addEntry(hash, key, value, i);

23 return null;

24 }

25

26 // putForNullKey()的作用是将“key为null”键值对添加到table[0]位置

27 private V putForNullKey(V value) {

28 for (Entry<K,V> e = table[0]; e != null; e = e.next) {

29 if (e.key == null) {

30 V oldValue = e.value;

31 e.value = value;

32 // recordAccess()函数什么也没有做

33 e.recordAccess(this);

34 return oldValue;

35 }

36 }

37 // 添加第1个“key为null”的元素都table中的时候，会执行到这里。

38 // 它的作用是将“设置table[0]的key为null，值为value”。

39 modCount++;

40 addEntry(0, null, value, 0);

41 return null;

42 }

Hashtable的添加key-value的方法

1 // 将“key-value”添加到Hashtable中

2 public synchronized V put(K key, V value) {

3 // Hashtable中不能插入value为null的元素！！！

4 if (value == null) {

5 throw new NullPointerException();

6 }

7

8 // 若“Hashtable中已存在键为key的键值对”，

9 // 则用“新的value”替换“旧的value”

10 Entry tab[] = table;

11 // Hashtable中不能插入key为null的元素！！！

12 // 否则，下面的语句会抛出异常！

13 int hash = key.hashCode();

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

15 for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {

16 if ((e.hash == hash) && e.key.equals(key)) {

17 V old = e.value;

18 e.value = value;

19 return old;

20 }

21 }

22

23 // 若“Hashtable中不存在键为key的键值对”，

24 // (01) 将“修改统计数”+1

25 modCount++;

26 // (02) 若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)

27 // 则调整Hashtable的大小

28 if (count >= threshold) {

29 // Rehash the table if the threshold is exceeded

30 rehash();

31

32 tab = table;

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

34 }

35

36 // (03) 将“Hashtable中index”位置的Entry(链表)保存到e中 Entry<K,V> e = tab[index];

37 // (04) 创建“新的Entry节点”，并将“新的Entry”插入“Hashtable的index位置”，并设置e为“新的Entry”的下一个元素(即“新Entry”为链表表头)。

38 tab[index] = new Entry<K,V>(hash, key, value, e);

39 // (05) 将“Hashtable的实际容量”+1

40 count++;

41 return null;

42 }

根据上面的代码，我们可以看出：

Hashtable的key或value，都不能为null！否则，会抛出异常NullPointerException。

HashMap的key、value都可以为null。 当HashMap的key为null时，HashMap会将其固定的插入table[0]位置(即HashMap散列表的第一个位置)；而且table[0]处只会容纳一个key为null的值，当有多个key为null的值插入的时候，table[0]会保留最后插入的value。

4 支持的遍历种类不同

HashMap只支持Iterator(迭代器)遍历。

而Hashtable支持Iterator(迭代器)和Enumeration(枚举器)两种方式遍历。

Enumeration 是JDK 1.0添加的接口，只有hasMoreElements(), nextElement() 两个API接口，不能通过Enumeration()对元素进行修改 。

而Iterator 是JDK 1.2才添加的接口，支持hasNext(), next(), remove() 三个API接口。HashMap也是JDK 1.2版本才添加的，所以用Iterator取代Enumeration，HashMap只支持Iterator遍历。

5 通过Iterator迭代器遍历时，遍历的顺序不同

HashMap是“从前向后”的遍历数组；再对数组具体某一项对应的链表，从表头开始进行遍历。

Hashtabl是“从后往前”的遍历数组；再对数组具体某一项对应的链表，从表头开始进行遍历。

HashMap和Hashtable都实现Map接口，所以支持获取它们“key的集合”、“value的集合”、“key-value的集合”，然后通过Iterator对这些集合进行遍历。

由于“key的集合”、“value的集合”、“key-value的集合”的遍历原理都是一样的；下面，我以遍历“key-value的集合”来进行说明。

HashMap 和Hashtable 遍历”key-value集合”的方式是：(01) 通过entrySet()获取“Map.Entry集合”。 (02) 通过iterator()获取“Map.Entry集合”的迭代器，再进行遍历。

HashMap的实现方式：先“从前向后”的遍历数组；对数组具体某一项对应的链表，则从表头开始往后遍历。

1 // 返回“HashMap的Entry集合”

2 public Set<Map.Entry<K,V>> entrySet() {

3 return entrySet0();

4 }

5 // 返回“HashMap的Entry集合”，它实际是返回一个EntrySet对象

6 private Set<Map.Entry<K,V>> entrySet0() {

7 Set<Map.Entry<K,V>> es = entrySet;

8 return es != null ? es : (entrySet = new EntrySet());

9 }

10 // EntrySet对应的集合

11 // EntrySet继承于AbstractSet，说明该集合中没有重复的EntrySet。

12 private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {

13 …

14 public Iterator<Map.Entry<K,V>> iterator() {

15 return newEntryIterator();

16 }

17 …

18 }

19 // 返回一个“entry迭代器”

20 Iterator<Map.Entry<K,V>> newEntryIterator() {

21 return new EntryIterator();

22 }

23 // Entry的迭代器

24 private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {

25 public Map.Entry<K,V> next() {

26 return nextEntry();

27 }

28 }

29 private abstract class HashIterator<E> implements Iterator<E> {

30 // 下一个元素

31 Entry<K,V> next;

32 // expectedModCount用于实现fail-fast机制。

33 int expectedModCount;

34 // 当前索引

35 int index;

36 // 当前元素

37 Entry<K,V> current;

38

39 HashIterator() {

40 expectedModCount = modCount;

41 if (size > 0) { // advance to first entry

42 Entry[] t = table;

43 // 将next指向table中第一个不为null的元素。

44 // 这里利用了index的初始值为0，从0开始依次向后遍历，直到找到不为null的元素就退出循环。

45 while (index < t.length && (next = t[index++]) == null)

46 ;

47 }

48 }

49

50 public final boolean hasNext() {

51 return next != null;

52 }

53

54 // 获取下一个元素

55 final Entry<K,V> nextEntry() {

56 if (modCount != expectedModCount)

57 throw new ConcurrentModificationException();

58 Entry<K,V> e = next;

59 if (e == null)

60 throw new NoSuchElementException();

61

62 // 注意！！！

63 // 一个Entry就是一个单向链表

64 // 若该Entry的下一个节点不为空，就将next指向下一个节点;

65 // 否则，将next指向下一个链表(也是下一个Entry)的不为null的节点。

66 if ((next = e.next) == null) {

67 Entry[] t = table;

68 while (index < t.length && (next = t[index++]) == null)

69 ;

70 }

71 current = e;

72 return e;

73 }

74

75 …

76 }

Hashtable的实现方式：先从“后向往前”的遍历数组；对数组具体某一项对应的链表，则从表头开始往后遍历。

1 public Set<Map.Entry<K,V>> entrySet() {

2 if (entrySet==null)

3 entrySet = Collections.synchronizedSet(new EntrySet(), this);

4 return entrySet;

5 }

6

7 private class EntrySet extends AbstractSet<Map.Entry<K,V>> {

8 public Iterator<Map.Entry<K,V>> iterator() {

9 return getIterator(ENTRIES);

10 }

11 …

12 }

13

14 private class Enumerator<T> implements Enumeration<T>, Iterator<T> {

15 // 指向Hashtable的table

16 Entry[] table = Hashtable.this.table;

17 // Hashtable的总的大小

18 int index = table.length;

19 Entry<K,V> entry = null;

20 Entry<K,V> lastReturned = null;

21 int type;

22

23 // Enumerator是 “迭代器(Iterator)” 还是 “枚举类(Enumeration)”的标志

24 // iterator为true，表示它是迭代器；否则，是枚举类。

25 boolean iterator;

26

27 // 在将Enumerator当作迭代器使用时会用到，用来实现fail-fast机制。

28 protected int expectedModCount = modCount;

29

30 Enumerator(int type, boolean iterator) {

31 this.type = type;

32 this.iterator = iterator;

33 }

34

35 // 从遍历table的数组的末尾向前查找，直到找到不为null的Entry。

36 public boolean hasMoreElements() {

37 Entry<K,V> e = entry;

38 int i = index;

39 Entry[] t = table;

40 /* Use locals for faster loop iteration */

41 while (e == null && i > 0) {

42 e = t[–i];

43 }

44 entry = e;

45 index = i;

46 return e != null;

47 }

48

49 // 获取下一个元素

50 // 注意：从hasMoreElements() 和nextElement() 可以看出“Hashtable的elements()遍历方式”

51 // 首先，从后向前的遍历table数组。table数组的每个节点都是一个单向链表(Entry)。

52 // 然后，依次向后遍历单向链表Entry。

53 public T nextElement() {

54 Entry<K,V> et = entry;

55 int i = index;

56 Entry[] t = table;

57 /* Use locals for faster loop iteration */

58 while (et == null && i > 0) {

59 et = t[–i];

60 }

61 entry = et;

62 index = i;

63 if (et != null) {

64 Entry<K,V> e = lastReturned = entry;

65 entry = e.next;

66 return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);

67 }

68 throw new NoSuchElementException(“Hashtable Enumerator”);

69 }

70

71 // 迭代器Iterator的判断是否存在下一个元素

72 // 实际上，它是调用的hasMoreElements()

73 public boolean hasNext() {

74 return hasMoreElements();

75 }

76

77 // 迭代器获取下一个元素

78 // 实际上，它是调用的nextElement()

79 public T next() {

80 if (modCount != expectedModCount)

81 throw new ConcurrentModificationException();

82 return nextElement();

83 }

84

85 …

86

87 }

6 容量的初始值 和 增加方式都不一样

HashMap默认的容量大小是16；增加容量时，每次将容量变为“原始容量x2”。

Hashtable默认的容量大小是11；增加容量时，每次将容量变为“原始容量x2 + 1”。

HashMap默认的“加载因子”是0.75, 默认的容量大小是16。

1 // 默认的初始容量是16，必须是2的幂。

2 static final int DEFAULT_INITIAL_CAPACITY = 16;

3

4 // 默认加载因子

5 static final float DEFAULT_LOAD_FACTOR = 0.75f;

6

7 // 指定“容量大小”的构造函数

8 public HashMap(int initialCapacity) {

9 this(initialCapacity, DEFAULT_LOAD_FACTOR);

10 }

当HashMap的 “实际容量” >= “阈值”时，(阈值 = 总的容量 * 加载因子)，就将HashMap的容量翻倍。

1 // 新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。

2 void addEntry(int hash, K key, V value, int bucketIndex) {

3 // 保存“bucketIndex”位置的值到“e”中

4 Entry<K,V> e = table[bucketIndex];

5 // 设置“bucketIndex”位置的元素为“新Entry”，

6 // 设置“e”为“新Entry的下一个节点”

7 table[bucketIndex] = new Entry<K,V>(hash, key, value, e);

8 // 若HashMap的实际大小 不小于 “阈值”，则调整HashMap的大小

9 if (size++ >= threshold)

10 resize(2 * table.length);

11 }

Hashtable默认的“加载因子”是0.75, 默认的容量大小是11。

1 // 默认构造函数。

2 public Hashtable() {

3 // 默认构造函数，指定的容量大小是11；加载因子是0.75

4 this(11, 0.75f);

5 }

当Hashtable的 “实际容量” >= “阈值”时，(阈值 = 总的容量 x 加载因子)，就将变为“原始容量x2 + 1”。

1 // 调整Hashtable的长度，将长度变成原来的(2倍+1)

2 // (01) 将“旧的Entry数组”赋值给一个临时变量。

3 // (02) 创建一个“新的Entry数组”，并赋值给“旧的Entry数组”

4 // (03) 将“Hashtable”中的全部元素依次添加到“新的Entry数组”中

5 protected void rehash() {

6 int oldCapacity = table.length;

7 Entry[] oldMap = table;

8

9 int newCapacity = oldCapacity * 2 + 1;

10 Entry[] newMap = new Entry[newCapacity];

11

12 modCount++;

13 threshold = (int)(newCapacity * loadFactor);

14 table = newMap;

15

16 for (int i = oldCapacity ; i– > 0