LinkedHashMap简介

LinkedHashMap继承了HashMap类，默认情况下使用entryset获取的集合顺序是与节点的插入顺序一致的。除去hashmap的逻辑之外，LinkedHashMap中还维护了一个双向链表，当新建待插入的Entry(LinkedHashMap中的Entry类继承了HashMap中的Node类)时，entry中新加了两个指针属性分别是before、after，分别指向之前和之后插入的节点。同时LinkedHashMap中多了3个参数，head、tail，accessOrder，双向链表默认是按照插入的顺序进行排列的，最先插入的节点(即最老的节点)为head，最新插入的节点为tail。accessOrder参数表示双向列表的排列顺序是按照节点的插入顺序还是访问顺序，默认是false即插入顺序，true代表的是访问顺序。在如下构造方法中我们可以指定访问模式。

 public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }

当排列模式是按访问顺序时，如果调用了get或put方法且key存在时，会调用afterNodeAccess方法，将最近被访问的节点移至双向队列的队尾。

下面说一下LinkedHashMap相对于HashMap重写了的部分：

1、LinkedHashMap并没有重写put方法，我们可以打开HashMap的put方法看一下，实际它调用了putval方法，在其中又分为待插入node的key已存在，待插入node的key在原map中不存在两种情况，不同情况执行完后对应的后续方法又不同，若key已存在则执行afterNodeAccess(node e)方法，key不存在则会使用newNode方法创建节点对象，插入后后会调用afterNodeInsertion(boolean evict)，具体代码如下所示

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null); //新建一个待插入节点
        else {
            /*中间的逻辑被我省略了*/

            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e); //key已存在
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict); //key不存在，新插入node
        return null;
    }



 void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        if (accessOrder && (last = tail) != e) { //判断了accessOrder的值
            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;
        }
    }


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);
        }
    }
//removeEldestEntery默认实现
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }

LinkedHashMap虽然没有重写put方法，但是它重写了afterNodeAccess和newNode、afterNodeInsertion方法，简单来说，在afterNodeAccess方法中会将最近访问到的节点移至双向队列的队尾，需要特别指出的是到默认情况下，若accessOrder为默认false(按插入顺序时)，此时afterNodeAccess方法是不生效的，代码中有一个判断只有当accessOrder为true(按访问顺序展示)时才会将被访问的节点放到双向队列队尾；在newNode方法中会使用linkedNodeLast方法，将新创建的节点添加入双向队列的队尾；在afterNodeInsertion方法中会调用removeEldestEntry方法，若它返回为true则会把当前双向队列的head节点从map中删除掉，当然也会从双向队列删除该节点，但removeEldestEntry默认返回是false，因此在通常使用中afterNodeInsertion方法不生效。

2、LinkedHashMap重写了get方法，但它的get方法的主要逻辑于HashMap的相差不大，唯一的区别是get方法主逻辑后会调用afterNodeAccess方法，但还是那句话accessOrder为false时该方法不生效。

3、LinkedHashMap未重写remove方法，但是重写了其中的afterNodeRemove方法，在该方法中会将被删除节点从双向琏表中移除。

上面简单介绍了LinkedHashMap的实现，默认为按照插入顺序展示，当accessOrder为true按照访问顺序展示时，我们可以使用其实现简单的lru，最近最少使用算法，保持一个最近被使用的队列。被使用包括两种含义：最近被访问或最近刚插入，因此我们要使用的为访问模式。下面给出一个简单的代码，实现了一个lru，保存最近使用的n个节点

import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCache extends LinkedHashMap<Integer, Integer> {

  private int capacity;

  public LRUCache(int capacity) {
    super(capacity, 0.75f, true);
    this.capacity = capacity;
  }

  public int get(int key) {
    return containsKey(key) ? super.get(key) : -1;
  }

  public void put(int key, int value) {
    super.put(key, value);
  }

  @Override
  protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
    return size() > capacity;
  }
}