概述
LinkedHashMap 继承了 HashMap。LinkedHashMap内部维护了一个双向链表，能保证元素按插入的顺序访问，也能以访问顺序访问，可以用来实现LRU缓存策略。
LinkedHashMap可以看成是 LinkedList + HashMap。
LinkedHashMap 的类继承结构图：
我们知道 HashMap 是无序的，即迭代器的顺序与插入顺序没什么关系。而 LinkedHashMap 在 HashMap 的基础上增加了顺序：分别为「插入顺序」和「访问顺序」。即遍历 LinkedHashMap 时，可以保持与插入顺序一致的顺序；或者与访问顺序一致的顺序。
LinkedHashMap 内部如何实现这两种顺序的呢？它是通过一个双链表来维持的。因此可以将 LinkedHashMap 理解为「双链表 + 散列表」，或者“有序的散列表”。
源码分析
1、节点类 Entry
LinkedHashMap 内部有一个嵌套类 Entry，它继承自 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) {
super(hash, key, value, next);
}
}
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
// ...
}该 Entry 类就是 LinkedHashMap 中的节点类。可以看到，它在 Node 类的基础上又增加了 before 和 after 两个变量，它们保存的是节点的前驱和后继（从字面意思也可以进行推测），从而来维护 LinkedHashMap 的顺序。
2、成员变量
/**
* 双向链表头节点
*/
transient LinkedHashMap.Entry<K,V> head;
/**
* 双向链表尾节点
*/
transient LinkedHashMap.Entry<K,V> tail;
/**
* 是否按访问顺序排序
*/
final boolean accessOrder;（1）head
双向链表的头节点，旧数据存在头节点。
（2）tail
双向链表的尾节点，新数据存在尾节点。
（3）accessOrder
是否需要按访问顺序排序，如果为false则按插入顺序存储元素，如果是true则按访问顺序存储元素。
3、构造器
/**
* Constructs an empty insertion-ordered LinkedHashMap instance
* with the default initial capacity (16) and load factor (0.75).
*/
public LinkedHashMap() {
super();
accessOrder = false;
}这里的 super() 方法调用了 HashMap 的无参构造器。该构造器方法构造了一个容量为 16（默认初始容量）、负载因子为 0.75（默认负载因子）的空 LinkedHashMap，其顺序为插入顺序。
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}可以看到上面几个构造器都是通过调用父类（HashMap）的构造器方法初始化，对此不再进行分析。前面 4 个构造器的 accessOrder 变量默认值都为 false；最后一个稍微不一样，它的 accessOrder 可以在初始化时指定，即指定 LinkedHashMap 的顺序（插入或访问顺序）。
4、常用方法
put 方法：
LinkedHashMap 本身没有实现 put 方法，它通过调用父类（HashMap）的方法来进行读写操作。
get方法：
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}如果查找到了元素，且accessOrder为true，则调用afterNodeAccess()方法把访问的节点移到双向链表的末尾。
afterNodeAccess(Node<K,V> e)方法：
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
// 如果accessOrder为true，并且访问的节点不是尾节点
if (accessOrder && (last = tail) != e) {
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
// 把p节点从双向链表中移除
p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a != null)
a.before = b;
else
last = b;
// 把p节点放到双向链表的末尾
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
// 尾节点等于p
tail = p;
++modCount;
}
}（1）如果accessOrder为true，并且访问的节点不是尾节点；
（2）从双向链表中移除访问的节点；
（3）把访问的节点加到双向链表的末尾；（末尾为最新访问的元素）
总结
（1）LinkedHashMap继承自HashMap，具有HashMap的所有特性；
（2）LinkedHashMap内部维护了一个双向链表存储所有的元素；
（3）如果accessOrder为false，则可以按插入元素的顺序遍历元素；
（4）如果accessOrder为true，则可以按访问元素的顺序遍历元素；
（5）LinkedHashMap的实现非常精妙，很多方法都是在HashMap中留的钩子（Hook），直接实现这些Hook就可以实现对应的功能了，并不需要再重写put()等方法；
（6）默认的LinkedHashMap并不会移除旧元素，如果需要移除旧元素，则需要重写removeEldestEntry()方法设定移除策略；
（7）LinkedHashMap可以用来实现LRU缓存淘汰策略；
