JAVA基础08-集合框架（八）Map总结(HashMap, Hashtable, TreeMap, WeakHashMap等使用场景)

（1）Map概况
1、 Map 是“键值对”映射的抽象接口。
2、 AbstractMap 实现了Map中的绝大部分函数接口。它减少了“Map的实现类”的重复编码。
3、 SortedMap 有序的“键值对”映射接口。
4、 NavigableMap 是继承于SortedMap的，支持导航函数的接口。
5、 HashMap, Hashtable, TreeMap, WeakHashMap这4个类是“键值对”映射的实现类。它们各有区别！

HashMap 是基于“拉链法”实现的散列表。一般用于单线程程序中。
　　Hashtable 也是基于“拉链法”实现的散列表。它一般用于多线程程序中。
　　WeakHashMap 也是基于“拉链法”实现的散列表，它一般也用于单线程程序中。相比HashMap，WeakHashMap中的键是“弱键”，当“弱键”被GC回收时，它对应的键值对也会被从WeakHashMap中删除；而HashMap中的键是强键。
　　TreeMap 是有序的散列表，它是通过红黑树实现的。它一般用于单线程中存储有序的映射。
　　
（2）HashMap和Hashtable异同
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。

接下来，说说“动态回收”的步骤。

(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）示例
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);
}

}
}