【源码分析】Java集合框架源码分析（二）

接着上一篇继续讲，上一篇讲了一下HashMap，其实Map接口用的最多的实现就是HashMap，也是最复杂的一个。下面我们继续讲其他的实现类：LinkedHashMap、IdentityHashMap、TreeMap、WeakHashMap。

1.LinkedHashMap

LinkedHashMap他是继承的HashMap，增删改都是原用的HashMap的增删改查。唯一的区别就是遍历的时候，他记录了HashMap的插入链表，可以把顺序打印出来。

        Map<String, String> hashMap = new HashMap<String, String>();
        hashMap.put("name1", "josan1");
        hashMap.put("name2", "josan2");
        hashMap.put("name3", "josan3");
        Set<Entry<String, String>> set = hashMap.entrySet();
        Iterator<Entry<String, String>> iterator = set.iterator();
        while(iterator.hasNext()) {
            Entry entry = iterator.next();
            String key = (String) entry.getKey();
            String value = (String) entry.getValue();
            System.out.println("key:" + key + ",value:" + value);
        }

这个是默认是按照插入的顺序。我们来看看构造函数：

    public LinkedHashMap() {
        // 调用HashMap的构造方法，其实就是初始化Entry[] table
        super();
        // fasle：代表插入顺序  true：访问顺序，也就是说 你get的时候 这个key就会被移动到队尾
        accessOrder = false;
    }
    
    @Test
    public void test(){
        // 第三个参数用于指定accessOrder值
        Map<String, String> linkedHashMap = new LinkedHashMap<>(16, 0.75f, true);
        linkedHashMap.put("name1", "josan1");
        linkedHashMap.put("name2", "josan2");
        linkedHashMap.put("name3", "josan3");
        System.out.println("开始时顺序：");
        Set<Map.Entry<String, String>> set = linkedHashMap.entrySet();
        Iterator<Map.Entry<String, String>> iterator = set.iterator();
        while(iterator.hasNext()) {
            Map.Entry entry = iterator.next();
            String key = (String) entry.getKey();
            String value = (String) entry.getValue();
            System.out.println("key:" + key + ",value:" + value);
        }
        System.out.println("通过get方法，导致key为name2对应的Entry到表尾");
        linkedHashMap.get("name2");
        Set<Map.Entry<String, String>> set2 = linkedHashMap.entrySet();
        Iterator<Map.Entry<String, String>> iterator2 = set2.iterator();
        while(iterator2.hasNext()) {
            Map.Entry entry = iterator2.next();
            String key = (String) entry.getKey();
            String value = (String) entry.getValue();
            System.out.println("key:" + key + ",value:" + value);
        }
    }

顺序是通过重新Entry，新增了两个指针 after和before来实现的

    /**
     * HashMap.Node subclass for normal LinkedHashMap entries.
     */
    static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;//新增两个指针
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }

2.IdentityHashMap
此类实现Map接口利用哈希表，比较键（和值）时使用引用相等代替对象相等的。 换句话说，在IdentityHashMap中 ，当且仅(k1==k2)时，两个键k1和k2被认为是相等的。 这个类用的比较少，不做详细讲解。

3.TreeMap
TreeMap底层是用的红黑二叉树实现的，比较简单。在使用的过程中，需要注意要么传入一个比较器（Compator），要么元素的key要实现Compable接口。

4.WeakHashMap
如果一个健没有其他强引用指向他的话，在下一次垃圾回收的时候，这个键就会被回收，在使用的map的时候，就会对该键值对清除掉。在学习这个类的时候，首先要了解java的引用。jdk5对java的引用重新定义了。之前是要么对象存在引用，要么不存在引用。在jdk5的时候，引用分为四种：强引用、软引用、弱引用、虚引用。这个java.lang.ref包下面的类：

强引用：就是我们平时new 对象的就是强引用。
SoftReference：当系统内存不足时，才会回收该对象的值。
WeakReference：每次GC的时候，都会回收该对象的值。
PhantomReference：这个类不能获取到对象的值，用于记录对象的回收轨迹，创建时必须传入ReferenceQueue。

    @Test
    public void test2(){
        WeakReference<Object> weakReference = new WeakReference<>(new Object(), new ReferenceQueue<>());
        System.out.println(weakReference.get());
        System.out.println(weakReference.isEnqueued());
        //强制GC 因为GC的时间不确定，必须到达安全点的才会触发GC或者内存不足的时候
        System.gc();
        System.out.println(weakReference.get());
        System.out.println(weakReference.isEnqueued());
    }

    @Test
    public void test(){
        Object object = new Object();
        WeakHashMap<Object,String> map = new WeakHashMap<>();
        map.put(object, "lisi");
        System.out.println(map.size());
        object = null;
        System.gc();
        System.out.println(map.size());
    }

那在了解这些引用的时候，再来看看WeakHashMap就很好理解了，直接看代码：

    /**
     * The entries in this hash table extend WeakReference, using its main ref
     * field as the key.
     */
    private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
    	//这里只有value，没有key  key是从WeakReference的get方法获取
        V value;
        final int hash;
        Entry<K,V> next;

        Entry(Object key, V value,
              ReferenceQueue<Object> queue,
              int hash, Entry<K,V> next) {
             //存放key  queue记录已经被回收的key，后面会取出来remove掉这个键值对
            super(key, queue);
            this.value = value;
            this.hash  = hash;
            this.next  = next;
        }

        @SuppressWarnings("unchecked")
        public K getKey() {
            return (K) WeakHashMap.unmaskNull(get());
        }

        public V getValue() {
            return value;
        }

        public V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
    }

参考：

LinkedHashMap：https://www.jianshu.com/p/8f4f58b4b8ab