1. 简介

java.util.LinkedHashMap<K,V> 就是带链表的 HashMap；每一种数据结构都有其优势，同时也有其劣势，这使得不同的数据结构适用于不同的应用场景，但在实际应用中，有很多复杂和动态的应用场景通常需要采用不同的数据结构来处理，这个时候就需要组合不同的数据结构来满足特定应用场景的需求，LinkedHashMap 就是一种组合数据结构的实现，它组合了链表和哈希表，不仅仅具有哈希表快速的随机存取能力，同时又保持了元素的插入或者访问顺序，可以通过链表对元素按照其插入或访问顺序进行快速的遍历。
LinkedHashMap 组合了双向链表和哈希表，关于哈希表和 HashMap 可看这篇《HashMap》，本文主要说明一下链表。

2. 链表

链表是一种线性表的一种存储方式（线性表的另外一种存储方式是顺序表，也就是数组），链表由节点构成，每一个节点包含两种域，一种是数值域，用来保存表元素值，一种是指针域，用来保存指向其他节点的指针；如果节点有一个数值域，一个保存下一个元素的指针域（也叫 next 指针域），这种叫做单链表，我们通过单链表的头节点，沿着 next 指针域就可以遍历整个单链表，如果我们在节点中再增加一个指针域，让这个域指向当前节点的前驱节点（这个域也叫 prior 指针域），这时链表就变成了双向链表，双向链表可以通过尾节点沿着 prior 指针域反向遍历整个链表。

2.1 链表和顺序表（数组）的对比

链表基本操作的时间复杂度和数组的比较如下：

通过上表我们可以看到，链表的优势在于插入和删除节点的时候不需要移动其他元素，只需要修改指针，所以插入和删除操作的时间复杂度都是O(1)；而顺序表的插入和删除操作（除了尾部元素）需要移动其他元素，时间负责度为O(n)；但是对链表进行随机访问（随机访问就是访问链表中任意位置的元素）时，需要遍历比对，因此时间复杂度为O(n)；而顺序表可以通过下标直接访问，时间负责度为O(1)。这里还有个令人困惑的问题：对于链表来说，无论是否知道元素位置，都需要遍历比对，那么对于顺序表，如果不知道元素位置（数组下标），是不是也需要遍历比对？这样是不是在随机访问方面，顺序表比链表也就没有什么优势了？当然不是了，顺序表在随机访问上的优势就是快速定位，即使不知道元素的位置，也不需要遍历比对整个列表，可以通过其他方式进行快速查找，比如：对于有序列表可以采用折半查找，对于无序列表可以使用哈希查找法等，当然无论采取哪种查找法，其时间复杂度都远远小于 O(n) 。

2.2 小结

链表的优势在于快速的插入和删除，而顺序表的优势在于快速随机查找；当我们即需要支持快速的插入和删除又需要支持快速的随机查找的时候，就可以想办法混合使用这两种数据结构，使用拉链法的哈希表就是顺序表和链表的一个混合数据结构，他融合了链表和顺序表的优势，不仅可以快速的插入和删除元素而且能够快速的进行随机查找。

3. JDK中LinkedHashMap的实现

下面是 LinkedHashMap 的部分源码，我们看到 LinkedHashMap 直接继承了 java.util.HashMap，所以关于哈希表的实现部分，LinkedHashMap 完全继承了 HashMap，LinkedHashMap 主要是在此基础之上，实现了一个双向链表。

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>{
    /**
     * HashMap.Node subclass for normal LinkedHashMap entries.
     */
    static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after; //before指向前驱节点，after指向后继节点
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }
    /**
     * The head (eldest) of the doubly linked list.
     */
    transient LinkedHashMap.Entry<K,V> head;//头节点，指向第一个插入的元素节点

    /**
     * The tail (youngest) of the doubly linked list.
     */
    transient LinkedHashMap.Entry<K,V> tail;//尾节点，指向最后一个插入的元素节点

    final boolean accessOrder;

    ...
}

通过上面的代码，我们看到 LinkedHashMap 的元素节点类 Entry 直接继承了 HashMap 的元素类HashMap.Node<K,V>，在其基础上增加了两个指针域，一个前驱指针域 before，用于指向前驱节点，一个后继指针域 after，用于指向后继节点，同时在 LinkedHashMap 内部增加了两个成员变量 head 和 tail 分别指向双向链表的头节点和尾节点；LinkedHashMap 利用 Entry 实例的前驱和后继指针域将表中的元素按照插入顺序或者访问顺序（插入操作也是一种访问操作，访问操作包括插入和读取，具体哪种顺序，由成员变量 accessOrder 的值决定，如果 accessOrder = true 则采用访问顺序，否则采用插入顺序）串联起来，同时让 head 指向最早插入或访问的节点，tail 指向最后插入或访问的节点，这样在哈希表之外，又形成了一个双向链表。同时，在每次执行会使表结构发生变化的操作时（比如插入，删除，rehash 等操作），都需要同时更新链表和哈希表。

4. LinkedHashMap的应用

通过前文的讲解，我们已经知道了 LinkedHashMap 维护了两个数据结构，一个哈希表和一个双向链表，是一种典型的组合数据结构，双向链表保持了元素的插入顺序或访问顺序，哈希表用于对元素进行快速的随机访问，这比起 HashMap 来说不仅仅增加了存储空间的使用，而且每次执行插入、删除操作时，都需要同时更新链表和哈希表，这也增加了一定的开销。我们来看看 LinkedHashMap 的应用场景。

4.1 实现缓存

LinkedHashMap 非常适合用来实现 FIFO，和 LRU 缓存。

4.1.1 FIFO 缓存

FIFO 是一种缓存元素置换算法，全称是 First In First Out（先来先出），其思想是当缓存空间已满，又有新的元素需要插入时，将最早插入缓存的元素移除，腾出空间插入新的元素。我们知道 LinkedHashMap 中的双向链表可以保持元素的插入顺序（也是默认的顺序），只需要将其 accessOrder 属性的值设为 false，当双向链表保持的是插入顺序时，其表头指针 head 会一直指向最早插入LinkedHashMap 的元素，最近插入的元素会排在队尾，当需要进行元素置换时，只需要删除头节点，将新节点插入队尾即可。

4.1.2 LRU 缓存

LRU 也是一种缓存元素置换算法，全称是 Least Recently Used（最近最少使用），其思想是当缓存已满，又需要插入新元素时，将最近一直未使用的元素移除，腾出空间插入新元素，LRU 缓存比起 FIFO 要高效很多。当 LinkedHashMap 的属性 accessOrder = true，双向链表保持的时元素的访问顺序（访问包括插入和读取），因此在 accessOrder = true 时，LinkedHashMap 会将新插入的元素放在队尾，并且，在每次已有元素被访问之后，会将被访问的元素重新移动到队尾。我们看以下代码，afterNodeAccess 方法在每次节点被访问后（compute、get、replace 等方法中）被调用，其作用就是将被访问的节点移动到双向列表尾部（如果该节本身就在尾部则什么都不做）。在这种方式下，双向链表中的元素保持了他们的访问顺序，最后被访问（插入或读取）的元素在队尾，最近一直未被访问的元素会不断前移，直到成为头节点。当需要进行元素置换时，删除头节点，将新节点插入队尾即可。

    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; //p是当前节点
            LinkedHashMap.Entry<K,V> b = p.before; //b表示前驱节点
            LinkedHashMap.Entry<K,V> a = p.after; //a表示后继节点
            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;
        }
    }

4.1.2 如何实现

具体如何实现这两种缓存呢？LinkedHashMap 已经帮我们完成了绝大多数工作，还有部分工作需要我们完成。我们先看下LinkedHashMap 中 afterNodeInsertion 方法（该方法在节点插入后调用）的实现；

    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(first) 返回 true 时，会删除头节点（evict只有在创建 LinkedHashMap 时才会为 false，否则都是 true），我们再看看 removeEldestEntry 方法；

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

我们看到 removeEldestEntry 方法只返回 false，removeEldestEntry 是留给用户重写的，LinkedHashMap 虽然实现了元素置换功能，但是否需要置换，何时置换，需要用户根据具体需求进行实现。下面的代码我们实现了一个简单的 LRU 缓存，继承了 LinkedHashMap，设置 accessOrder = true，当 LinkedHashMap 内的元素数量超过指定的容量时，开始进行元素置换。

public class LRUCache extends LinkedHashMap<String, Object>{

    private static final long serialVersionUID = 1L;

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

    @Override
    protected boolean removeEldestEntry(java.util.Map.Entry<String, Object> eldest) {
        return this.size() > this.capacity;
    }
}