基本原理
LinkedHashMap继承自HashMap，因此具有HashMap的所有特性。在HashMap的基础上，保持了key的插入顺序或者访问顺序。实现方法就是用双向循环链表将所有的entry链接起来，读取数据的时候直接读取此双向循环链表的数据即可。
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V> /**
* The head of the doubly linked list.
*/
private transient Entry<K,V> header;
/**
* The iteration ordering method for this linked hash map:
* true for access-order,false for insertion-order.
*/
private final boolean accessOrder;header是双向循环链表的头结点，不存储数据，用于定位头尾节点
header.after指向链表的第一个节点
header.before指向链表的最后一个节点
accessOrder是一个标志位，true的话表示按照访问顺序访问链表，可据此构建LRU缓存，fasle的话表示按照插入顺序访问链表
双向循环链表的Entry节点
LinkedHashMap的Entry继承自HashMap的Entry
private static class Entry<K,V> extends HashMap.Entry<K,V> 并添加了指向前序节点的前序指针和指向后继节点的后继指针
// These fields comprise the doubly linked list used for iteration.
Entry<K,V> before, after;因此LinkedHashMap的Entry节点具有三个指针域，next指针维护Hash桶中冲突key的链表，before和after维护双向循环链表
为了维护双向循环链表，Entry新增加了4个方法
删除节点remove
/**
* Removes this entry from the linked list.
*/
private void remove() {
before.after = after;
after.before = before;
}充分体现了链表这种数据结构删除中间节点的方便之处，仅仅修改指针的指向即可。
如果要删除当前节点，就把当前节点的前序节点的后继指针指向当前节点的后继节点，当前节点的后继节点的前序指针指向当前节点的前序节点即可，这样当前节点就从链表中脱离开了，断开的节点也得到重新链接。
添加节点
/**
* Inserts this entry before the specified existing entry in the list.
*/
private void addBefore(Entry<K,V> existingEntry) {
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}添加节点同样是指针操作，非常高效方便
记录访问recordAccess
/**
* This method is invoked by the superclass whenever the value
* of a pre-existing entry is read by Map.get or modified by Map.set.
* If the enclosing Map is access-ordered, it moves the entry
* to the end of the list; otherwise, it does nothing.
*/
void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
if (lm.accessOrder) {
lm.modCount++;
remove();
addBefore(lm.header);
}
}当LinkedHashMap的标志位accessOrder为true时，标志着要采用访问顺序访问链表。
remove(); addBefore(lm.header);
最新访问的节点先从原来的位置删除，然后重现添加到链表的末尾，这样最近最少访问的节点就被挪到了链表的前端。
LinkedHashMap添加数据
LinkedHashMap本质上也是一个HashMap，在HashMap的基础上添加所有entry构成双向循环链表的功能。因此LinkedHashMap并没有覆写HashMap的put方法，只是覆写了HashMap中put方法调用的addEntry方法。
先来回顾下HashMap的put方法够干了什么
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}HashMap的put方法主要功能是计算对应key的桶的位置，遍历桶中链表，找到对应key的entry修改原数据。遍历链表结束没有找到对应key的entry则调用addEntry方法将新添加的键值对entry添加到桶中entry链表的头部。
而对于LinkedHashMap中的entry节点来说，要维持两个链表，一个是桶中的next指针域链接的hask冲突的key构成的entry单链表，第二个就是维护所有entry构成的双向循环链表
LinkedHashMap的addEntry方法如下所示
void addEntry(int hash, K key, V value, int bucketIndex) {
createEntry(hash, key, value, bucketIndex);
// Remove eldest entry if instructed, else grow capacity if appropriate
Entry<K,V> eldest = header.after;
if (removeEldestEntry(eldest)) {
removeEntryForKey(eldest.key);
} else {
if (size >= threshold)
resize(2 * table.length);
}
}先调用createEntry把新节点链接到两条链表上，然后判断是否要删除最近最久未访问的节点(也就是双向循环链表的第一个节点)，要删除的话就不需要检查是否需要扩容了，都则要检查是否需要扩容。
void createEntry(int hash, K key, V value, int bucketIndex) {
HashMap.Entry<K,V> old = table[bucketIndex];
Entry<K,V> e = new Entry<K,V>(hash, key, value, old);
table[bucketIndex] = e;
e.addBefore(header);
size++;
}可见新节点被两条链表都链接上了
第一条是单项非循环链表，桶中hash值冲突得key构成的entry链表
HashMap.Entry<K,V> old = table[bucketIndex];
Entry<K,V> e = new Entry<K,V>(hash, key, value, old);
table[bucketIndex] = e;第二条是所有entry节点构成的双向循环链表
e.addBefore(header);containsValue方法直接在双向循环链表中查找值
public boolean containsValue(Object value) {
// Overridden to take advantage of faster iterator
if (value==null) {
for (Entry e = header.after; e != header; e = e.after)
if (e.value==null)
return true;
} else {
for (Entry e = header.after; e != header; e = e.after)
if (value.equals(e.value))
return true;
}
return false;
}根据传入参数value是否为null，对双向循环链表进行遍历查找