副标题#e#
Map总结(HashMap, Hashtable, TreeMap, WeakHashMap等利用场景)
学完了Map的全部内容，我们再转头开开Map的框架图。
第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的界说:
publicclass HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable { ... }
Hashtable的界说:
publicclass 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”的要领
#p#分页标题#e#
HashMap的添加key-value的要领
// 将“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的要领
// 将“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;
}
按照上面的代码，我们可以看出：
#p#副标题#e#
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迭代器遍历时，遍历的顺序差异
#p#分页标题#e#
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的实现方法：先“从前向后”的遍历数组；对数组详细某一项对应的链表，则从表头开始往后遍历。
// 返回“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 容量的初始值 和 增加方法都纷歧样
#p#分页标题#e#
HashMap默认的容量巨细是16；增加容量时，每次将容量变为“原始容量x2”。 Hashtable默认的容量巨细是11；增加容量时，每次将容量变为“原始容量x2 + 1”。
HashMap默认的“加载因子”是0.75, 默认的容量巨细是16。
// 默认的初始容量是16，必需是2的幂。
static final int DEFAULT_INITIAL_CAPACITY = 16;
// 默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 指定“容量巨细”的结构函数
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
当HashMap的 “实际容量” >= “阈值”时，(阈值 = 总的容量 * 加载因子)，就将HashMap的容量翻倍。
// 新增Entry。将“key-value”插入指定位置，bucketIndex是位置索引。
void addEntry(int hash, K key, V value, int bucketIndex) {
// 生存“bucketIndex”位置的值到“e”中
Entry<K,V> e = table[bucketIndex];
// 配置“bucketIndex”位置的元素为“新Entry”，
// 配置“e”为“新Entry的下一个节点”
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
// 若HashMap的实际巨细 不小于 “阈值”，则调解HashMap的巨细
if (size++ >= threshold)
resize(2 * table.length);
}
Hashtable默认的“加载因子”是0.75, 默认的容量巨细是11。
1 // 默认结构函数。 2 public Hashtable() { 3 // 默认结构函数，指定的容量巨细是11；加载因子是0.75 4 this(11, 0.75f); 5 }
当Hashtable的 “实际容量” >= “阈值”时，(阈值 = 总的容量 x 加载因子)，就将变为“原始容量x2 + 1”。
// 调解Hashtable的长度，将长度酿本钱来的(2倍+1)
// (01) 将“旧的Entry数组”赋值给一个姑且变量。
// (02) 建设一个“新的Entry数组”，并赋值给“旧的Entry数组”
// (03) 将“Hashtable”中的全部元素依次添加到“新的Entry数组”中
protected void rehash() {
int oldCapacity = table.length;
Entry[] oldMap = table;
int newCapacity = oldCapacity * 2 + 1;
Entry[] newMap = new Entry[newCapacity];
modCount++;
threshold = (int)(newCapacity * loadFactor);
table = newMap;
for (int i = oldCapacity ; i-- > 0 ;) {
for (Entry<K,V> old = oldMap[i] ; old != null ; ) {
Entry<K,V> e = old;
old = old.next;
int index = (e.hash & 0x7FFFFFFF) % newCapacity;
e.next = newMap[index];
newMap[index] = e;
}
}
}
7 添加key-value时的hash值算法差异
HashMap添加元素时，是利用自界说的哈希算法。 Hashtable没有自界说哈希算法，而直接回收的key的hashCode()。
#p#分页标题#e#
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差异
查察本栏目
Hashtable支持contains(Object value)要领，并且重写了toString()要领； 而HashMap不支持contains(Object value)要领，没有重写toString()要领。
最后，再说说“HashMap和Hashtable”利用的情景。 其实，若相识它们之间的差异之处后，可以很容易的区分按照环境举办取舍。譬喻：(01) 若在单线程中，我们往往会选择HashMap；而在多线程中，则会选择Hashtable。(02)，若不能插入null元素，则选择Hashtable；不然，可以选择HashMap。 但这个不是绝对的尺度。譬喻，在多线程中，我们可以本身对HashMap举办同步，也可以选择ConcurrentHashMap。当HashMap和Hashtable都不能满意本身的需求时，还可以思量新界说一个类，担任或从头实现散列表；虽然，一般环境下是不需要的了。
——————————————————————————–
第3部门 HashMap和WeakHashMap异同
3.1 HashMap和WeakHashMap的沟通点
1 它们都是散列表，存储的是“键值对”映射。 2 它们都担任于AbstractMap，而且实现Map基本。 3 它们的结构函数都一样。它们都包罗4个结构函数，并且函数的参数都一样。 4 默认的容量巨细是16，默认的加载因子是0.75。 5 它们的“键”和“值”都答允为null。 6 它们都是“非同步的”。
3.2 HashMap和WeakHashMap的差异点
1 HashMap实现了Cloneable和Serializable接口，而WeakHashMap没有。HashMap实现Cloneable，意味着它能通过clone()克隆本身。HashMap实现Serializable，意味着它支持序列化，能通过序列化去传输。
2 HashMap的“键”是“强引用(StrongReference)”，而WeakHashMap的键是“弱引用(WeakReference)”。WeakReference的“弱键”能实现WeakReference对“键值对”的动态接纳。当“弱键”不再被利用到时，GC会接纳它，WeakReference也会将“弱键”对应的键值对删除。这个“弱键”实现的动态接纳“键值对”的道理呢？其实，通过WeakReference(弱引用)和ReferenceQueue(引用行列)实现的。 首先，我们需要相识WeakHashMap中： 第一，“键”是WeakReference，即key是弱键。 第二，ReferenceQueue是一个引用行列，它是和WeakHashMap连系利用的。当弱引用所引用的工具被垃圾接纳，Java虚拟机就会把这个弱引用插手到与之关联的引用行列中。 WeakHashMap中的ReferenceQueue是queue。第三，WeakHashMap是通过数组实现的，我们假设这个数组是table。
接下来，说说“动态接纳”的步调。
#p#分页标题#e#
(01) 新建WeakHashMap，将“键值对”添加到WeakHashMap中。将“键值对”添加到WeakHashMap中时，添加的键都是弱键。实际上，WeakHashMap是通过数组table生存Entry(键值对)；每一个Entry实际上是一个单向链表，即Entry是键值对链表。 (02) 当某“弱键”不再被其它工具引用，并被GC接纳时。在GC接纳该“弱键”时，这个“弱键”也同时会被添加到queue行列中。譬喻，当我们在将“弱键”key添加到WeakHashMap之后；厥后将key设为null。这时，便没有外部外部工具再引用该了key。接着，当Java虚拟机的GC接纳内存时，会接纳key的相关内存；同时，将key添加到queue行列中。 (03) 当下一次我们需要操纵WeakHashMap时，会先同步table和queue。table中生存了全部的键值对，而queue中生存被GC接纳的“弱键”；同步它们，就是删除table中被GC接纳的“弱键”对应的键值对。譬喻，当我们“读取WeakHashMap中的元素或获取WeakReference的巨细时”，它会先同步table和queue，目标是“删除table中被GC接纳的‘弱键’对应的键值对”。删除的要领就是逐个较量“table中元素的‘键’和queue中的‘键’”，若它们相当，则删除“table中的该键值对”。
3.3 HashMap和WeakHashMap的较量测试措施
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.Date;
import java.lang.ref.WeakReference;
/**
* @desc HashMap 和 WeakHashMap较量措施
*
* @author skywang
* @email kuiwu-wang@163.com
*/
public class CompareHashmapAndWeakhashmap {
public static void main(String[] args) throws Exception {
// 当“弱键”是String时，较量HashMap和WeakHashMap
compareWithString();
// 当“弱键”是自界说范例时，较量HashMap和WeakHashMap
compareWithSelfClass();
}
/**
* 遍历map，并打印map的巨细
*/
private static void iteratorAndCountMap(Map map) {
// 遍历map
for (Iterator iter = map.entrySet().iterator();
iter.hasNext(); ) {
Map.Entry en = (Map.Entry)iter.next();
System.out.printf("map entry : %s - %s\n ",en.getKey(), en.getValue());
}
// 打印HashMap的实际巨细
System.out.printf(" map size:%s\n\n", map.size());
}
/**
* 通过String工具测试HashMap和WeakHashMap
*/
private static void compareWithString() {
// 新建4个String字符串
String w1 = new String("W1");
String w2 = new String("W2");
String h1 = new String("H1");
String h2 = new String("H2");
// 新建 WeakHashMap工具，并将w1,w2添加到 WeakHashMap中
Map wmap = new WeakHashMap();
wmap.put(w1, "w1");
wmap.put(w2, "w2");
// 新建 HashMap工具，并将h1,h2添加到 WeakHashMap中
Map hmap = new HashMap();
hmap.put(h1, "h1");
hmap.put(h2, "h2");
// 删除HashMap中的“h1”。
// 功效：删除“h1”之后，HashMap中只有 h2 ！
hmap.remove(h1);
// 将WeakHashMap中的w1配置null，并执行gc()。系统会接纳w1
// 功效：w1是“弱键”，被GC接纳后，WeakHashMap中w1对应的键值对，也会被从WeakHashMap中删除。
// w2是“弱键”，但它不是null，不会被GC接纳；也就不会被从WeakHashMap中删除。
// 因此，WeakHashMap中只有 w2
// 留意：若去掉“w1=null” 可能“System.gc()”，功效城市纷歧样！
w1 = null;
System.gc();
// 遍历并打印HashMap的巨细
System.out.printf(" -- HashMap --\n");
iteratorAndCountMap(hmap);
// 遍历并打印WeakHashMap的巨细
System.out.printf(" -- WeakHashMap --\n");
iteratorAndCountMap(wmap);
}
/**
* 通过自界说类测试HashMap和WeakHashMap
*/
private static void compareWithSelfClass() {
// 新建4个自界说工具
Self s1 = new Self(10);
Self s2 = new Self(20);
Self s3 = new Self(30);
Self s4 = new Self(40);
// 新建 WeakHashMap工具，并将s1,s2添加到 WeakHashMap中
Map wmap = new WeakHashMap();
wmap.put(s1, "s1");
wmap.put(s2, "s2");
// 新建 HashMap工具，并将s3,s4添加到 WeakHashMap中
Map hmap = new HashMap();
hmap.put(s3, "s3");
hmap.put(s4, "s4");
// 删除HashMap中的s3。
// 功效：删除s3之后，HashMap中只有 s4 ！
hmap.remove(s3);
// 将WeakHashMap中的s1配置null，并执行gc()。系统会接纳w1
// 功效：s1是“弱键”，被GC接纳后，WeakHashMap中s1对应的键值对，也会被从WeakHashMap中删除。
// w2是“弱键”，但它不是null，不会被GC接纳；也就不会被从WeakHashMap中删除。
// 因此，WeakHashMap中只有 s2
// 留意：若去掉“s1=null” 可能“System.gc()”，功效城市纷歧样！
s1 = null;
System.gc();
/*
// 休眠500ms
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
// */
// 遍历并打印HashMap的巨细
System.out.printf(" -- Self-def HashMap --\n");
iteratorAndCountMap(hmap);
// 遍历并打印WeakHashMap的巨细
System.out.printf(" -- Self-def WeakHashMap --\n");
iteratorAndCountMap(wmap);
}
private static class Self {
int id;
public Self(int id) {
this.id = id;
}
// 包围finalize()要领
// 在GC接纳时会被执行
protected void finalize() throws Throwable {
super.finalize();
System.out.printf("GC Self: id=%d addr=0x%s)\n", id, this);
}
}
}
