Map集合--LinkedHashMap1.8

LinkedHashMap(1.8)

LinkedHashMap 继承了 HasahMap，并且它的存储结构也是继承了 HashMap 的 Node 类；

LinkedHashMap 是一个非线程安全的集合，使用用双向链表的结构，把所有存储在 HashMap 中的数据连接起来，LinkedHashMap 的默认实现是按插入顺序排序的（只是用前后指针去链接，但底层的存放还是无序的）；

LinkedHashMap 还可以用来实现 LRU （Least recently used，最近最少使用）算法；

LRU 算法：最近最少使用，意思就是最近读取的数据放在最前面，最早读取的数据放在最后面，如果这个时候有新的数据进来，那么最后面存储的数据淘汰；

存储结构

LinkedHashMap = HashMap + 双向链表

	//继承了 HashMap 的 Node 类
	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) {
            //存放数据还是 HashMap 中的 Entry
            super(hash, key, value, next);
        }
    }
	//双向列表尾节点（最新）
	transient LinkedHashMap.Entry<K,V> head;

    //双向链表头节点（最老）
    transient LinkedHashMap.Entry<K,V> tail;

---

构造器

属性 accessOrder（迭代顺序的默认值）：默认情况下是 false，也就是默认情况下维护的是插入顺序。如果设置成 true 就可以将访问过的数据就排到最前面；

    //下面五个构造器中，都是调用了它的父类HashMap中的构造器，accessOrder 开始都是 false
	public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
    }

    public LinkedHashMap(int initialCapacity) {
        super(initialCapacity);
        accessOrder = false;
    }

    public LinkedHashMap() {
        super();
        accessOrder = false;
    }

    public LinkedHashMap(Map<? extends K, ? extends V> m) {
        super();
        accessOrder = false;
        putMapEntries(m, false);
    }

---

添加

在 LinkedHashMap 中添加元素时都是调用它的父类 HashMap 中的方法的，但是它是如何在遍历时有序的呢？也就是说，它的 before 和 after 指针是如何维护的呢？

首先，在 LinkedHashMap 中，它重写了 init 方法以便初始化双向列表，因此，在创建 LinkedHashMap 的同时就会不知不觉地对双向链表进行初始化；

	void init() {
        header = new Entry<K,V>(-1, null, null, null);
        header.before = header.after = header;
    }

在 LinkedHashMap 中它重写了 HashMap 中的 newNode 创建结点的方法，而在该方法中就对指针做了操作；

也就是在该方法中，链接了插入的元素，本质就是一个双向链表的插入；

因此，LinkedHashMap 的存储，获取以及删除，都和HashMap 是一样的，只不过就是维护了一个双向链表；

	Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
        //创建出目前要插入的Entry结点 p
        LinkedHashMap.Entry<K,V> p =
            new LinkedHashMap.Entry<K,V>(hash, key, value, e);
        linkNodeLast(p);
        return p;
    }
	private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
        //获取链表尾结点
        LinkedHashMap.Entry<K,V> last = tail;
        //将目前要插入的结点 p 赋值给 尾结点（尾指针）tail
        tail = p;
        //如果last（也就是之前的尾结点）为空，说明是第一次插入元素，那么将p结点也赋值给头节点
        if (last == null)
            head = p;
        else {
            //否则，之前的元素赋值给p的before
            p.before = last;
            //p再赋值给last的after
            last.after = p;
        }
    }

---

LRU 算法

LinkedHashMap 区别于 HashMap 最大的一个不同点是，前者是有序的，而后者是无序的。为此，LinkedHashMap 增加了两个属性用于保证顺序，分别是双向链表头结点 header 和标志位 accessOrder；

header 是 LinkedHashMap 所维护的双向链表的头结点，而 accessOrder 用于决定具体的迭代顺序；

afterNodeAccess()

当一个节点被访问时，如果 accessOrder 为 true，则会将该节点移到链表尾部。也就是说指定为 LRU 顺序之后，在每次访问一个节点时，会将这个节点移到链表尾部，保证链表尾部是最近访问的节点，那么链表首部就是最近最久未使用的节点；

void afterNodeAccess(Node<K,V> e) { // move node to last
    LinkedHashMap.Entry<K,V> last;
    if (accessOrder && (last = tail) != e) {
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        p.after = null;
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a != null)
            a.before = b;
        else
            last = b;
        if (last == null)
            head = p;
        else {
            p.before = last;
            last.after = p;
        }
        tail = p;
        ++modCount;
    }
}

---

afterNodeInsertion()

在 put 等操作之后执行，当 removeEldestEntry() 方法返回 true 时会移除最晚的节点，也就是链表首部节点 first。

evict 只有在构建 Map 的时候才为 false，在这里为 true。

	void afterNodeInsertion(boolean evict) { // possibly remove eldest
        LinkedHashMap.Entry<K,V> first;
        if (evict && (first = head) != null && removeEldestEntry(first)) {
            K key = first.key;
            removeNode(hash(key), key, null, false, true);
        }
    }

removeEldestEntry() 默认为 false，如果需要让它为 true，需要继承 LinkedHashMap 并且覆盖这个方法的实现，这在实现 LRU 的缓存中特别有用，通过移除最近最久未使用的节点，从而保证缓存空间足够，并且缓存的数据都是热点数据。

    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }

LRU 缓存

以下是使用 LinkedHashMap 实现的一个 LRU 缓存：

• 设定最大缓存空间 MAX_ENTRIES 为 3；
• 使用 LinkedHashMap 的构造函数将 accessOrder 设置为 true，开启 LRU 顺序；
• 覆盖 removeEldestEntry() 方法实现，在节点多于 MAX_ENTRIES 就会将最近最久未使用的数据移除；

class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private static final int MAX_ENTRIES = 3;

    protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > MAX_ENTRIES;
    }

    LRUCache() {
        super(MAX_ENTRIES, 0.75f, true);
    }
}

public static void main(String[] args) {
    LRUCache<Integer, String> cache = new LRUCache<>();
    cache.put(1, "a");
    cache.put(2, "b");
    cache.put(3, "c");
    cache.get(1);
    cache.put(4, "d");
    System.out.println(cache.keySet());
}

结果：[3, 1, 4]

---