WeakHashMap

WeakHashMap继承AbstractMap，实现了Map接口。

WeakHashMap内部使用了数组、队列的结构。

    //方法继承了弱引用，当WeakHashMap引用对象为弱引用时，gc会对key-value进行回收
    private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
        V value;
        final int hash;
        Entry<K,V> next;

        //构造方法，引用队列
        Entry(Object key, V value,
              ReferenceQueue<Object> queue,
              int hash, Entry<K,V> next) {
            super(key, queue);
            this.value = value;
            this.hash  = hash;
            this.next  = next;
        }

        //允许key=null，但是对null进行了包装
        //private static final Object NULL_KEY = new Object();
        @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;
        }

        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            K k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                V v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

        public int hashCode() {
            K k = getKey();
            V v = getValue();
            return Objects.hashCode(k) ^ Objects.hashCode(v);
        }

        public String toString() {
            return getKey() + "=" + getValue();
        }
    }

WeakHashMap之所以weak，内部最关键的方法是expungeStaleEntries()

//调用isEmpty()，size(),put(K key, V value),get(Object key)方法，都会调用该方法，以对key进行"回收"。
private void expungeStaleEntries() {
        for (Object x; (x = queue.poll()) != null; ) {
            synchronized (queue) {
                @SuppressWarnings("unchecked")
                    Entry<K,V> e = (Entry<K,V>) x;
                int i = indexFor(e.hash, table.length);

                Entry<K,V> prev = table[i];
                Entry<K,V> p = prev;
                while (p != null) {
                    Entry<K,V> next = p.next;
                    if (p == e) {
                        if (prev == e)
                            table[i] = next;
                        else
                            prev.next = next;

                        e.value = null; // Help GC
                        size--;
                        break;
                    }
                    prev = p;
                    p = next;
                }
            }
        }
    }

put(K key, V value)

    public V put(K key, V value) {
        //对key=null的值包装
        Object k = maskNull(key);
        int h = hash(k);
        Entry<K,V>[] tab = getTable();
        int i = indexFor(h, tab.length);

        //如果有重复数据，直接覆盖并返回旧值
        for (Entry<K,V> e = tab[i]; e != null; e = e.next) {
            if (h == e.hash && eq(k, e.get())) {
                V oldValue = e.value;
                if (value != oldValue)
                    e.value = value;
                return oldValue;
            }
        }

        modCount++;
        Entry<K,V> e = tab[i];
        tab[i] = new Entry<>(k, value, queue, h, e);
        //扩容，默认大小为16，容量>3/4时进行扩容，每次扩容当前容量的两倍
        if (++size >= threshold)
            resize(tab.length * 2);
        return null;
    }

get(Object key)

public V get(Object key) {
        //包装key=null的元素
        Object k = maskNull(key);
        int h = hash(k);
        Entry<K,V>[] tab = getTable();
        int index = indexFor(h, tab.length);
        Entry<K,V> e = tab[index];
        while (e != null) {
            //元素在数组中
            if (e.hash == h && eq(k, e.get()))
                return e.value;
            //元素在队列中，循环队列
            e = e.next;
        }
        return null;
    }

remove(Object key)

    public V remove(Object key) {
        Object k = maskNull(key);
        int h = hash(k);
        Entry<K,V>[] tab = getTable();
        int i = indexFor(h, tab.length);
        Entry<K,V> prev = tab[i];
        Entry<K,V> e = prev;

        //存在对应的元素
        while (e != null) {
            Entry<K,V> next = e.next;
            if (h == e.hash && eq(k, e.get())) {
                modCount++;
                size--;
                if (prev == e)
                    tab[i] = next;
                else
                    prev.next = next;
                return e.value;
            //循环队列
            prev = e;
            e = next;
        }

        return null;
    }

总结

1. WeakHashMap内部使用数组、队列结构存储数据。
2. WeakHashMap内部数据无序。
3. WeakHashMap允许key=null，value=null，但是会把key=null包装成Object。
   4. 当调用isEmpty()，size(),put(K key, V value),get(Object key)方法时，WeakHashMap内部会对不经常引用的key值进行回收。

JDK版本1.8.0_92。