LinkedHashMap源码
LinkedHashMap继承了HashMap,HashMap具有的特性LinkedHashMap也有。
public class LinkedHashMap
extends HashMap
implements Map LinkedHashMap与HashMap不同的是，除了拥有与HashMap一样的存储结构之外，又额外维护了一个双向链表，默认按照插入顺序排列，也可以通过设置accessOrder字段实现LRU算法，此时按照访问顺序对节点排列。
1.LinkedHashMap的存储结构Entry
Entry继承了HashMap的Node，并且多出了两个字段before和after，这两个字段在构造双向链表时使用
/**
* linkedHashMap的存储结构，继承了HashMap的Node
*/
static class Entry extends HashMap.Node {
//比HashMap多出了两个成员变量before和after，构造双向链表使用，before指向当前节点在双向链表中的前一个节点，after指向后一个节点
Entry before, after;
Entry(int hash, K key, V value, Node next) {
//调用Node中的构造函数实例化对象
super(hash, key, value, next);
}
} 2.字段
（1）双向链表有一个头结点head和尾节点tail
（2）accessOrder为true的时候表示双向链表按照访问顺序排列，为false表示按照插入顺序排列。
private static final long serialVersionUID = 3801124242820219131L;
/**
* 双向链表的头结点
*/
transient LinkedHashMap.Entry head;
/**
* 双向链表的尾节点
*/
transient LinkedHashMap.Entry tail;
/**
* true表示双向链表按照访问的顺序来排列，false则表示按照插入顺序来排列
*/
final boolean accessOrder; 3.构造函数
（1）由于LinkedHashMap继承了HashMap,因此默认容量和加载因子与HashMap一致。
（2）需要实现LRU算法时，需要使用 public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder)构造函数，将accessOrder设为true。
/**
* 带有指定容量的构造函数
*/
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
/**
* 无参构造函数，使用默认容量16和默认加载因子0.75
*/
public LinkedHashMap() {
super();
accessOrder = false;
}
/**
* 构造函数
*/
public LinkedHashMap(Map m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
/**
* 构造函数，带有初始容量、加载因子和accessOrder
* accessOrder：true表示链表按照访问的顺序来排列，false则表示按照插入顺序来排列
*/
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
LinkedHashMap中并没有重写添加方法，而是直接使用了HashMap中的添加方法，但是重写了创建新节点的newNode方法：
/**
* 添加
*
* @param hash key的hash值
* @param key key值
* @param value value值
* @param onlyIfAbsent 如果已经存在包含key值的对象，onlyIfAbsent为true时不更新该对象的value，否则将更新为新的value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
//如果哈希表（数组）为空
if ((tab = table) == null || (n = tab.length) == 0)
//对哈希表扩容并返回哈希表的长度
n = (tab = resize()).length;
//根据hash计算在数组中的索引，并获取该索引处的对象，如果为空，创建节点，放到该索引处
if ((p = tab[i = (n - 1) & hash]) == null)
//创建新节点，放到索引为i的位置
tab[i] = newNode(hash, key, value, null);
else {
//如果索引处已经存在节点
Node e; K k;
//判断该节点的hash以及key值是否与要添加的对象的key相等
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//将第一个节点赋值给e，稍后更新e的value为新的value（根据onlyIfAbsent判断）
e = p;
else if (p instanceof TreeNode)
//如果是红黑树
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
else {
//从链表中查找，如果查找为空就将新节点从尾部添加（尾插法），如果根据hash和key在链表中查到，中断循环
for (int binCount = 0; ; ++binCount) {
//如果当前节点的下一个节点为空
if ((e = p.next) == null) {
//创建新的节点，链接到当前节点
p.next = newNode(hash, key, value, null);
//如果节点数超过了树化的阈值
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//将链表转为树
treeifyBin(tab, hash);
break;
}
//判断节点的hash以及key值是否与要添加的对象的key相等，中断查找
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) {
//获取旧的value
V oldValue = e.value;
//如果onlyIfAbsent为false或者旧的value是空，更新为新的value
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//如果长度超过了阈值
if (++size > threshold)
//调整大小
resize();
afterNodeInsertion(evict);
return null;
} newNode方法：
可以看到创建的是Entry节点，将节点添加到双向链表中并返回。
/**
* 创建新的Node节点
* @param hash
* @param key
* @param value
* @param e
* @return
*/
Node newNode(int hash, K key, V value, Node e) {
LinkedHashMap.Entry p =
new LinkedHashMap.Entry(hash, key, value, e);
//新节点链接尾插法插入链表
linkNodeLast(p);
return p;
}
/**
* 在双向链表中使用尾插法插入节点
* @param p
*/
private void linkNodeLast(LinkedHashMap.Entry p) {
LinkedHashMap.Entry last = tail;
tail = p;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
} 在添加节点时如果节点已经存，在更新节点的value后会调用afterNodeAccess(e)方法，在HashMap中此方法什么也没有做，在LinkedHashMap中对方法进行了重写，将当前节点放入到双向链表的尾部：
/**
* 该方法提供了LRU算法的实现，它将最近使用的节点放到双向循环链表的尾部
* @param e 要放到链表尾部的节点
*/
void afterNodeAccess(Node e) { // move node to last
LinkedHashMap.Entry last;
//如果accessOrder为true并且当前节点不是尾节点
if (accessOrder && (last = tail) != e) {
// e=p，代表要放到链表尾部的节点，b为它前一个节点，a为它指向的下一个节点
LinkedHashMap.Entry p =
(LinkedHashMap.Entry)e, b = p.before, a = p.after;
//将p的after设为null
p.after = null;
//如果p的一前个节点为空，说明p是头结点
if (b == null)
//将头结点设为p的下一个节点a
head = a;
else
//将p前一个节点的after指向a
b.after = a;
//如果p的后一个节点不为空
if (a != null)
//将a的前一个节点指向p的前一个节点b
a.before = b;
else
//如果p的后一个节点为空，将p的前一个节点先当做尾节点
last = b;
//如果尾节点为空
if (last == null)
//头结点
head = p;
else {
//将p的前一个节点指向尾节点
p.before = last;
// 原来的尾节点的下一个节点指向p
last.after = p;
}
//设置p为尾节点
tail = p;
++modCount;
}
} /**
* 删除最老的Entry
* 因为添加节点采用的尾插法，多次操作后，双向链表前面的Entry便是最近没有使用的
* 如果实现LRU，需要重写removeEldestEntry方法，不然只会返回false不会删除节点
* @param evict
*/
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry first;
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
//删除头结点
removeNode(hash(key), key, null, false, true);
}
} /**
* 是否移除最老的Entry
* 如果实现LRU，需要重写removeEldestEntry方法
*/
protected boolean removeEldestEntry(Map.Entry eldest) {
return false;
}
（1）containsValue直接从双向链表中查找，而不用遍历整个哈希表，提高了效率。
（2）通过key查找的方法还是从哈希表中查找，因为根据key可以直接定位到在hash表的索引。
（3）调用get获取对象时，如果accessOrder为true同样会调用afterNodeAccess方法，实现LRU。
/**
* 从双向链表中根据value查找对象
*/
public boolean containsValue(Object value) {
//遍历双向链表
for (LinkedHashMap.Entry e = head; e != null; e = e.after) {
V v = e.value;
if (v == value || (value != null && value.equals(v)))
return true;
}
return false;
}
/**
* 根据key获取对象，当查找为null时返回null
*/
public V get(Object key) {
Node e;
//根据key的hash值查找对象，如果为空返回null
if ((e = getNode(hash(key), key)) == null)
return null;
//如果链表中元素的排序规则是按照访问的先后顺序排序，将e链接到尾节点
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
/**
* 根据key获取对象，当查找为null时返回默认的值defaultValue
*/
public V getOrDefault(Object key, V defaultValue) {
Node e;
if ((e = getNode(hash(key), key)) == null)
return defaultValue;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
6.删除方法
LinkedHashMap使用HashMap中的删除方法，但是重写了afterNodeRemoval方法。
HashMap的删除方法：
/**
* 根据key删除节点
*
* @param hash hash for key
* @param key the key
* @param value the value to match if matchValue, else ignored
* @param matchValue if true only remove if value is equal
* @param movable if false do not move other nodes while removing
* @return the node, or null if none
*/
final Node removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node[] tab; Node p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node node = null, e; K k; V v;
//如果要删除的节点在头结点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
//如果是树结构
node = ((TreeNode)p).getTreeNode(hash, key);
else {
//如果是链表，遍历链表找到要删除的节点
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
//记录要删除节点的前一个节点
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
//如果是红黑树，从树中删除节点
((TreeNode)node).removeTreeNode(this, tab, movable);
else if (node == p)
//如果要删除的是头结点，也就是在tab[index]位置的元素，将该节点的下一个节点放到table[index]处
tab[index] = node.next;
else
//如果要删除的节点在链表中，记录要删除节点的前一个节点，将该节点的next执行要删除节点的下一个节点
p.next = node.next;
++modCount;
//更改大小
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
} linkedHashMap的afterNodeRemoval方法：
/**
* 将节点从双向链表中移除
* @param e
*/
void afterNodeRemoval(Node e) { // unlink
LinkedHashMap.Entry p =
(LinkedHashMap.Entry)e, b = p.before, a = p.after;
p.before = p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a == null)
tail = b;
else
a.before = b;
} 清空方法：
/**
* 清空，直接将头结点和尾节点设为null
*/
public void clear() {
super.clear();
head = tail = null;
}参考：
【Java集合源码剖析】LinkedHashmap源码剖析