参考：
https://www.cnblogs.com/xiaoxi/p/6170590.html
https://www.cnblogs.com/LiaHon/p/11180869.html
Java集合之LinkedHashMap
一、初识LinkedHashMap
上篇文章讲了HashMap。HashMap是一种非常常见、非常有用的集合，但在多线程情况下使用不当会有线程安全问题。
大多数情况下，只要不涉及线程安全问题，Map基本都可以使用HashMap，不过HashMap有一个问题，就是迭代HashMap的顺序并不是HashMap放置的顺序，也就是无序。HashMap的这一缺点往往会带来困扰，因为有些场景，我们期待一个有序的Map。
这个时候，LinkedHashMap就闪亮登场了，它虽然增加了时间和空间上的开销，但是通过维护一个运行于所有条目的双向链表，LinkedHashMap保证了元素迭代的顺序。该迭代顺序可以是插入顺序或者是访问顺序。
二、四个关注点在LinkedHashMap上的答案
| 关 注 点 | 结 论 |
| LinkedHashMap是否允许空 | Key和Value都允许空 |
| LinkedHashMap是否允许重复数据 | Key重复会覆盖、Value允许重复 |
| LinkedHashMap是否有序 | 有序 |
| LinkedHashMap是否线程安全 | 非线程安全 |
三、LinkedHashMap基本结构
关于LinkedHashMap，先提两点：
1、LinkedHashMap可以认为是HashMap+LinkedList，即它既使用HashMap操作数据结构，又使用LinkedList维护插入元素的先后顺序。
2、LinkedHashMap的基本实现思想就是----多态。可以说，理解多态，再去理解LinkedHashMap原理会事半功倍；反之也是，对于LinkedHashMap原理的学习，也可以促进和加深对于多态的理解。
为什么可以这么说，首先看一下，LinkedHashMap的定义：
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>
{
...
}
看到，LinkedHashMap是HashMap的子类，自然LinkedHashMap也就继承了HashMap中所有非private的方法。再看一下LinkedHashMap中本身的方法：
看到LinkedHashMap中并没有什么操作数据结构的方法，也就是说LinkedHashMap操作数据结构（比如put一个数据），和HashMap操作数据的方法完全一样，无非就是细节上有一些的不同罢了。
LinkedHashMap只定义了两个属性：
/** * 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. * true表示最近最少使用次序，false表示插入顺序 */ private final boolean accessOrder;
LinkedHashMap一共提供了五个构造方法：
// 构造方法1，构造一个指定初始容量和负载因子的、按照插入顺序的LinkedList
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
// 构造方法2，构造一个指定初始容量的LinkedHashMap，取得键值对的顺序是插入顺序
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
// 构造方法3，用默认的初始化容量和负载因子创建一个LinkedHashMap，取得键值对的顺序是插入顺序
public LinkedHashMap() {
super();
accessOrder = false;
}
// 构造方法4，通过传入的map创建一个LinkedHashMap，容量为默认容量（16）和(map.zise()/DEFAULT_LOAD_FACTORY)+1的较大者，装载因子为默认值
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super(m);
accessOrder = false;
}
// 构造方法5，根据指定容量、装载因子和键值对保持顺序创建一个LinkedHashMap
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
从构造方法中可以看出，默认都采用插入顺序来维持取出键值对的次序。所有构造方法都是通过调用父类的构造方法来创建对象的。
LinkedHashMap和HashMap的区别在于它们的基本数据结构上，看一下LinkedHashMap的基本数据结构，也就是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;
Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
super(hash, key, value, next);
}
...
}
列一下Entry里面有的一些属性吧：
1、K key
2、V value
3、Entry<K, V> next
4、int hash
5、Entry<K, V> before
6、Entry<K, V> after
其中前面四个，也就是红色部分是从HashMap.Entry中继承过来的；后面两个，也就是蓝色部分是LinkedHashMap独有的。不要搞错了next和before、After，next是用于维护HashMap指定table位置上连接的Entry的顺序的，before、After是用于维护Entry插入的先后顺序的。
还是用图表示一下，列一下属性而已：
第一张图为LinkedHashMap整体结构图，第二张图专门把循环双向链表抽取出来，直观一点，注意该循环双向链表的头部存放的是最久访问的节点或最先插入的节点，尾部为最近访问的或最近插入的节点，迭代器遍历方向是从链表的头部开始到链表尾部结束，在链表尾部有一个空的header节点，该节点不存放key-value内容，为LinkedHashMap类的成员属性，循环双向链表的入口。
四、初始化LinkedHashMap
假如有这么一段代码：
1 public static void main(String[] args)
2 {
3 LinkedHashMap<String, String> linkedHashMap =
4 new LinkedHashMap<String, String>();
5 linkedHashMap.put("111", "111");
6 linkedHashMap.put("222", "222");
7 }
首先是第3行~第4行，new一个LinkedHashMap出来，看一下做了什么：
通过源代码可以看出，在LinkedHashMap的构造方法中，实际调用了父类HashMap的相关构造方法来构造一个底层存放的table数组。
1 public LinkedHashMap() {
2 super();
3 accessOrder = false;
4 }
1 public HashMap() {
2 this.loadFactor = DEFAULT_LOAD_FACTOR;
3 threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
4 table = new Entry[DEFAULT_INITIAL_CAPACITY];
5 init();
6 }
我们已经知道LinkedHashMap的Entry元素继承HashMap的Entry，提供了双向链表的功能。在上述HashMap的构造器中，最后会调用init()方法，进行相关的初始化，这个方法在HashMap的实现中并无意义，只是提供给子类实现相关的初始化调用。
LinkedHashMap重写了init()方法，在调用父类的构造方法完成构造后，进一步实现了对其元素Entry的初始化操作。
1 void init() {
2 header = new Entry<K,V>(-1, null, null, null);
3 header.before = header.after = header;
4 }
这里出现了第一个多态：init()方法。尽管init()方法定义在HashMap中，但是由于：
1、LinkedHashMap重写了init方法
2、实例化出来的是LinkedHashMap
因此实际调用的init方法是LinkedHashMap重写的init方法。假设header的地址是0x00000000，那么初始化完毕，实际上是这样的：
注意这个header，hash值为-1，其他都为null，也就是说这个header不放在数组中，就是用来指示开始元素和标志结束元素的。
header的目的是为了记录第一个插入的元素是谁，在遍历的时候能够找到第一个元素。
五、LinkedHashMap存储元素
LinkedHashMap并未重写父类HashMap的put方法，而是重写了父类HashMap的put方法调用的子方法void recordAccess(HashMap m) ，void addEntry(int hash, K key, V value, int bucketIndex) 和void createEntry(int hash, K key, V value, int bucketIndex)，提供了自己特有的双向链接列表的实现。
继续看LinkedHashMap存储元素，也就是put("111","111")做了什么，首先当然是调用HashMap的put方法：
1 //这个方法应该挺熟悉的，如果看了HashMap的解析的话
2 public V put(K key, V value) {
3 //key为null的情况
4 if (key == null)
5 return putForNullKey(value);
6 //通过key算hash，进而算出在数组中的位置，也就是在第几个桶中
7 int hash = hash(key.hashCode());
8 int i = indexFor(hash, table.length);
9 //查看桶中是否有相同的key值，如果有就直接用新值替换旧值，而不用再创建新的entry了
10 for (Entry<K,V> e = table[i]; e != null; e = e.next) {
11 Object k;
12 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
13 V oldValue = e.value;
14 e.value = value;
15 e.recordAccess(this);
16 return oldValue;
17 }
18 }
19
20 modCount++;
21 //上面度是熟悉的东西，最重要的地方来了，就是这个方法，LinkedHashMap执行到这里，addEntry()方法不会执行HashMap中的方法，
22 //而是执行自己类中的addEntry方法，
23 addEntry(hash, key, value, i);
24 return null;
25 }
第23行又是一个多态，因为LinkedHashMap重写了addEntry方法，因此addEntry调用的是LinkedHashMap重写了的方法：
1 void addEntry(int hash, K key, V value, int bucketIndex) {
2 //调用create方法，将新元素以双向链表的的形式加入到映射中
3 createEntry(hash, key, value, bucketIndex);
4
5 // Remove eldest entry if instructed, else grow capacity if appropriate
6 // 删除最近最少使用元素的策略定义
7 Entry<K,V> eldest = header.after;
8 if (removeEldestEntry(eldest)) {
9 removeEntryForKey(eldest.key);
10 } else {
11 if (size >= threshold)
12 resize(2 * table.length);
13 }
14 }
因为LinkedHashMap由于其本身维护了插入的先后顺序，因此LinkedHashMap可以用来做缓存，第7行~第9行是用来支持FIFO算法的，这里暂时不用去关心它。看一下createEntry方法：
1 void createEntry(int hash, K key, V value, int bucketIndex) {
2 HashMap.Entry<K,V> old = table[bucketIndex];
3 Entry<K,V> e = new Entry<K,V>(hash, key, value, old);
4 table[bucketIndex] = e;
5 //将该节点插入到链表尾部
6 e.addBefore(header);
7 size++;
8 }
private void addBefore(Entry<K,V> existingEntry) {
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}
createEntry(int hash,K key,V value,int bucketIndex)方法覆盖了父类HashMap中的方法。这个方法不会拓展table数组的大小。该方法首先保留table中bucketIndex处的节点，然后调用Entry的构造方法（将调用到父类HashMap.Entry的构造方法）添加一个节点，即将当前节点的next引用指向table[bucketIndex] 的节点，之后调用的e.addBefore(header)是修改链表，将e节点添加到header节点之前。
第2行~第4行的代码和HashMap没有什么不同，新添加的元素放在table[i]上，差别在于LinkedHashMap还做了addBefore操作，这四行代码的意思就是让新的Entry和原链表生成一个双向链表。假设字符串111放在位置table[1]上，生成的Entry地址为0x00000001，那么用图表示是这样的：
如果熟悉LinkedList的源码应该不难理解，还是解释一下，注意下existingEntry表示的是header：
1、after=existingEntry，即新增的Entry的after=header地址，即after=0x00000000
2、before=existingEntry.before，即新增的Entry的before是header的before的地址，header的before此时是0x00000000，因此新增的Entry的before=0x00000000
3、before.after=this，新增的Entry的before此时为0x00000000即header，header的after=this，即header的after=0x00000001
4、after.before=this，新增的Entry的after此时为0x00000000即header，header的before=this，即header的before=0x00000001
这样，header与新增的Entry的一个双向链表就形成了。再看，新增了字符串222之后是什么样的，假设新增的Entry的地址为0x00000002，生成到table[2]上，用图表示是这样的：
就不细解释了，只要before、after清除地知道代表的是哪个Entry的就不会有什么问题。
注意，这里的插入有两重含义：
1.从table的角度看，新的entry需要插入到对应的bucket里，当有哈希冲突时，采用头插法将新的entry插入到冲突链表的头部。
2.从header的角度看，新的entry需要插入到双向链表的尾部。
总得来看，再说明一遍，LinkedHashMap的实现就是HashMap+LinkedList的实现方式，以HashMap维护数据结构，以LinkList的方式维护数据插入顺序。
六、LinkedHashMap读取元素
LinkedHashMap重写了父类HashMap的get方法，实际在调用父类getEntry()方法取得查找的元素后，再判断当排序模式accessOrder为true时（即按访问顺序排序），先将当前节点从链表中移除，然后再将当前节点插入到链表尾部。由于的链表的增加、删除操作是常量级的，故并不会带来性能的损失。
/**
* 通过key获取value，与HashMap的区别是：当LinkedHashMap按访问顺序排序的时候，会将访问的当前节点移到链表尾部(头结点的前一个节点)
*/
public V get(Object key) {
// 调用父类HashMap的getEntry()方法，取得要查找的元素。
Entry<K,V> e = (Entry<K,V>)getEntry(key);
if (e == null)
return null;
// 记录访问顺序。
e.recordAccess(this);
return e.value;
}
/**
* 在HashMap的put和get方法中，会调用该方法，在HashMap中该方法为空
* 在LinkedHashMap中，当按访问顺序排序时，该方法会将当前节点插入到链表尾部(头结点的前一个节点)，否则不做任何事
*/
void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
//当LinkedHashMap按访问排序时
if (lm.accessOrder) {
lm.modCount++;
//移除当前节点
remove();
//将当前节点插入到头结点前面
addBefore(lm.header);
}
}
/**
* 移除节点，并修改前后引用
*/
private void remove() {
before.after = after;
after.before = before;
}
private void addBefore(Entry<K,V> existingEntry) {
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}
七、利用LinkedHashMap实现LRU算法缓存
前面讲了LinkedHashMap添加元素，删除、修改元素就不说了，比较简单，和HashMap+LinkedList的删除、修改元素大同小异，下面讲一个新的内容。
LinkedHashMap可以用来作缓存，比方说LRUCache，看一下这个类的代码，很简单，就十几行而已：
public class LRUCache extends LinkedHashMap
{
public LRUCache(int maxSize)
{
super(maxSize, 0.75F, true);
maxElements = maxSize;
}
protected boolean removeEldestEntry(java.util.Map.Entry eldest)
{
return size() > maxElements;
}
private static final long serialVersionUID = 1L;
protected int maxElements;
}
顾名思义，LRUCache就是基于LRU算法的Cache（缓存），这个类继承自LinkedHashMap，而类中看到没有什么特别的方法，这说明LRUCache实现缓存LRU功能都是源自LinkedHashMap的。LinkedHashMap可以实现LRU算法的缓存基于两点：
1、LinkedList首先它是一个Map，Map是基于K-V的，和缓存一致
2、LinkedList提供了一个boolean值可以让用户指定是否实现LRU
那么，首先我们了解一下什么是LRU：LRU即Least Recently Used，最近最少使用，也就是说，当缓存满了，会优先淘汰那些最近最不常访问的数据。比方说数据a，1天前访问了；数据b，2天前访问了，缓存满了，优先会淘汰数据b。
我们看一下LinkedList带boolean型参数的构造方法：
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
就是这个accessOrder，它表示：
（1）false，所有的Entry按照插入的顺序排列
（2）true，所有的Entry按照访问的顺序排列
第二点的意思就是，如果有1 2 3这3个Entry，那么访问了1，就把1移到尾部去，即2 3 1。每次访问都把访问的那个数据移到双向队列的尾部去，那么每次要淘汰数据的时候，双向队列最头的那个数据不就是最不常访问的那个数据了吗？换句话说，双向链表最头的那个数据就是要淘汰的数据。
"访问"，这个词有两层意思：
1、根据Key拿到Value，也就是get方法
2、修改Key对应的Value，也就是put方法
首先看一下get方法，它在LinkedHashMap中被重写：
public V get(Object key) {
Entry<K,V> e = (Entry<K,V>)getEntry(key);
if (e == null)
return null;
e.recordAccess(this);
return e.value;
}
然后是put方法，沿用父类HashMap的：
1 public V put(K key, V value) {
2 if (key == null)
3 return putForNullKey(value);
4 int hash = hash(key.hashCode());
5 int i = indexFor(hash, table.length);
6 for (Entry<K,V> e = table[i]; e != null; e = e.next) {
7 Object k;
8 if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
9 V oldValue = e.value;
10 e.value = value;
11 e.recordAccess(this);
12 return oldValue;
13 }
14 }
15
16 modCount++;
17 addEntry(hash, key, value, i);
18 return null;
19 }
修改数据也就是第6行~第14行的代码。看到两端代码都有一个共同点：都调用了recordAccess方法，且这个方法是Entry中的方法，也就是说每次的recordAccess操作的都是某一个固定的Entry。
recordAccess，顾名思义，记录访问，也就是说你这次访问了双向链表，我就把你记录下来，怎么记录？把你访问的Entry移到尾部去。这个方法在HashMap中是一个空方法，就是用来给子类记录访问用的，看一下LinkedHashMap中的实现：
void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
if (lm.accessOrder) {
lm.modCount++;
remove();
addBefore(lm.header);
}
}
private void remove() {
before.after = after;
after.before = before;
}
private void addBefore(Entry<K,V> existingEntry) {
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}
看到每次recordAccess的时候做了两件事情：
1、把待移动的Entry的前后Entry相连
2、把待移动的Entry移动到尾部
当然，这一切都是基于accessOrder=true的情况下。最后用一张图表示一下整个recordAccess的过程吧：
void recordAccess(HashMap<K,V> m) 这个方法就是我们一开始说的，accessOrder为true时，就是使用的访问顺序，访问次数最少到访问次数最多，此时要做特殊处理。处理机制就是访问了一次，就将自己往后移一位，这里就是先将自己删除了，然后在把自己添加，这样，近期访问的少的就在链表的开始，最近访问的元素就会在链表的末尾。如果为false。那么默认就是插入顺序，直接通过链表的特点就能依次找到插入元素，不用做特殊处理。
八、代码演示LinkedHashMap按照访问顺序排序的效果
最后代码演示一下LinkedList按照访问顺序排序的效果，验证一下上一部分LinkedHashMap的LRU功能：
public static void main(String[] args)
{
LinkedHashMap<String, String> linkedHashMap =
new LinkedHashMap<String, String>(16, 0.75f, true);
linkedHashMap.put("111", "111");
linkedHashMap.put("222", "222");
linkedHashMap.put("333", "333");
linkedHashMap.put("444", "444");
loopLinkedHashMap(linkedHashMap);
linkedHashMap.get("111");
loopLinkedHashMap(linkedHashMap);
linkedHashMap.put("222", "2222");
loopLinkedHashMap(linkedHashMap);
}
public static void loopLinkedHashMap(LinkedHashMap<String, String> linkedHashMap)
{
Set<Map.Entry<String, String>> set = inkedHashMap.entrySet();
Iterator<Map.Entry<String, String>> iterator = set.iterator();
while (iterator.hasNext())
{
System.out.print(iterator.next() + " ");
}
System.out.println();
}
注意这里的构造方法要用三个参数那个且最后的要传入true，这样才表示按照访问顺序排序。看一下代码运行结果：
111=111 222=222 333=333 444=444 222=222 333=333 444=444 111=111 333=333 444=444 111=111 222=2222
代码运行结果证明了两点：
1、LinkedList是有序的
2、每次访问一个元素（get或put），被访问的元素都被提到最后面去了
LinkedHashMap如何保证顺序性
一. 前言
先看一个例子，我们想在页面展示一周内的消费变化情况，用echarts面积图进行展示。如下：
我们在后台将数据构造完成
HashMap<String, Integer> map = new HashMap<>();
map.put("星期一", 40);
map.put("星期二", 43);
map.put("星期三", 35);
map.put("星期四", 55);
map.put("星期五", 45);
map.put("星期六", 35);
map.put("星期日", 30);
然而页面上一展示，发现并非如此，我们打印出来看，发现顺序并非我们所想，先put进去的先get出来
for (Map.Entry<String, Integer> entry : map.entrySet()){
System.out.println("key: " + entry.getKey() + ", value: " + entry.getValue());
}
/**
* 结果如下：
* key: 星期二, value: 40
* key: 星期六, value: 35
* key: 星期三, value: 50
* key: 星期四, value: 55
* key: 星期五, value: 45
* key: 星期日, value: 65
* key: 星期一, value: 30
*/
那么如何保证预期展示结果如我们所想呢，这个时候就需要用到LinkedHashMap实体。
二. 初识LinkedHashMap
首先我们把上述代码用LinkedHashMap进行重构
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("星期一", 40);
map.put("星期二", 43);
map.put("星期三", 35);
map.put("星期四", 55);
map.put("星期五", 45);
map.put("星期六", 35);
map.put("星期日", 30);
for (Map.Entry<String, Integer> entry : map.entrySet()){
System.out.println("key: " + entry.getKey() + ", value: " + entry.getValue());
}
这个时候，结果正如我们所预期
key: 星期一, value: 40
key: 星期二, value: 43
key: 星期三, value: 35
key: 星期四, value: 55
key: 星期五, value: 45
key: 星期六, value: 35
key: 星期日, value: 30
LinkedHashMap继承了HashMap类，是HashMap的子类，LinkedHashMap的大多数方法的实现直接使用了父类HashMap的方法，关于HashMap在前面的章节已经讲过了，《HashMap原理(一) 概念和底层架构》，《HashMap原理(二) 扩容机制及存取原理》。
LinkedHashMap可以说是HashMap和LinkedList的集合体，既使用了HashMap的数据结构，又借用了LinkedList双向链表的结构（关于LinkedList可参考Java集合 LinkedList的原理及使用）,那么这样的结构如何实现的呢，我们看一下LinkedHashMap的类结构
我们看到LinkedHashMap中定义了一个Entry静态内部类，定义了5个构造器，一些成员变量，如head，tail，accessOrder，并继承了HashMap的方法，同时实现了一些迭代器方法。我们先看一下Entry类
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);
}
}
我们看到这个静态内部类很简单，继承了HashMap的Node内部类，我们知道Node类是HashMap的底层数据结构，实现了数组+链表/红黑树的结构，而Entry类保留了HashMap的数据结构，同时通过before，after实现了双向链表结构（HashMap中Node类只有next属性，并不具备双向链表结构）。那么before，after和next到底什么关系呢。
看上面的结构图，定义了头结点head，当我们调用迭代器进行遍历时，通过head开始遍历，通过before属性可以不断找到下一个，直到tail尾结点，从而实现顺序性。而在同一个hash（在上图中表现了同一行）链表内部after和next效果是一样的。不同点在于before和after可以连接不同hash之间的链表。
前面我们发现数据结构已经完全支持其顺序性了，接下来我们再看一下构造方法，看一下比起HashMap的构造方法是否有不同。
// 构造方法1，构造一个指定初始容量和负载因子的、按照插入顺序的LinkedList
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
// 构造方法2，构造一个指定初始容量的LinkedHashMap，取得键值对的顺序是插入顺序
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
// 构造方法3，用默认的初始化容量和负载因子创建一个LinkedHashMap，取得键值对的顺序是插入顺序
public LinkedHashMap() {
super();
accessOrder = false;
}
// 构造方法4，通过传入的map创建一个LinkedHashMap，容量为默认容量（16）和(map.zise()/DEFAULT_LOAD_FACTORY)+1的较大者，装载因子为默认值
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super(m);
accessOrder = false;
}
// 构造方法5，根据指定容量、装载因子和键值对保持顺序创建一个LinkedHashMap
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
我们发现除了多了一个变量accessOrder之外，并无不同，此变量到底起了什么作用？
/**
* The iteration ordering method for this linked hash map: <tt>true</tt>
* for access-order, <tt>false</tt> for insertion-order.
*
* @serial
*/
final boolean accessOrder;
通过注释发现该变量为true时access-order，即按访问顺序遍历，如果为false，则表示按插入顺序遍历。默认为false，在哪些地方使用到该变量了，同时怎么理解？我们可以看下面的方法介绍
二. put方法
前面我们提到LinkedHashMap的put方法沿用了父类HashMap的put方法，但我们也提到了像LinkedHashMap的Entry类就是继承了HashMap的Node类，同样的，HashMap的put方法中调用的其他方法在LinkedHashMap中已经被重写。我们先看一下HashMap的put方法，这个在《HashMap原理(二) 扩容机制及存取原理》中已经有说明，我们主要关注于其中的不同点
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing 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<K,V>[] tab; Node<K,V> p; int n, i;
/**
* 如果当前HashMap的table数组还未定义或者还未初始化其长度，则先通过resize()进行扩容,
* 返回扩容后的数组长度n
*/
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//通过数组长度与hash值做按位与&运算得到对应数组下标，若该位置没有元素，则new Node直接将新元素插入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//否则该位置已经有元素了，我们就需要进行一些其他操作
else {
Node<K,V> e; K k;
//如果插入的key和原来的key相同，则替换一下就完事了
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;
/**
* 否则key不同的情况下，判断当前Node是否是TreeNode,如果是则执行putTreeVal将新的元素插入
* 到红黑树上。
*/
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//如果不是TreeNode,则进行链表遍历
else {
for (int binCount = 0; ; ++binCount) {
/**
* 在链表最后一个节点之后并没有找到相同的元素，则进行下面的操作，直接new Node插入，
* 但条件判断有可能转化为红黑树
*/
if ((e = p.next) == null) {
//直接new了一个Node
p.next = newNode(hash, key, value, null);
/**
* TREEIFY_THRESHOLD=8,因为binCount从0开始，也即是链表长度超过8（包含）时，
* 转为红黑树。
*/
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
/**
* 如果在链表的最后一个节点之前找到key值相同的（和上面的判断不冲突，上面是直接通过数组
* 下标判断key值是否相同），则替换
*/
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
//onlyIfAbsent为true时:当某个位置已经存在元素时不去覆盖
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//最后判断临界值，是否扩容。
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
1. newNode方法
首先：LinkedHashMap重写了newNode()方法，通过此方法保证了插入的顺序性。
/**
* 使用LinkedHashMap中内部类Entry
*/
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
LinkedHashMap.Entry<K,V> p = new LinkedHashMap.Entry<K,V>(hash, key, value, e);
linkNodeLast(p);
return p;
}
/**
* 将新创建的节点p作为尾结点tail，
* 当然如果存储的第一个节点，那么它即是head节点，也是tail节点，此时节点p的before和after都为null
* 否则，建立与上一次尾结点的链表关系，将当前尾节点p的前一个节点（before）设置为上一次的尾结点last,
* 将上一次尾节点last的后一个节点（after）设置为当前尾结点p
* 通过此方法实现了双向链表功能，完成before,after,head,tail的值设置
*/
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;
tail = p;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
}
2. afterNodeAccess方法
其次：关于afterNodeAccess()方法，在HashMap中没给具体实现，而在LinkedHashMap重写了，目的是保证操作过的Node节点永远在最后，从而保证读取的顺序性，在调用put方法和get方法时都会用到。
/**
* 当accessOrder为true并且传入的节点不是最后一个时，将传入的node移动到最后一个
*/
void afterNodeAccess(Node<K,V> e) {
//在执行方法前的上一次的尾结点
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：当前节点
//b：当前节点的前一个节点
//a：当前节点的后一个节点；
//将p.after设置为null，断开了与后一个节点的关系，但还未确定其位置
p.after = null;
/**
* 因为将当前节点p拿掉了，那么节点b和节点a之间断开了，我们先站在节点b的角度建立与节点a
* 的关联，如果节点b为null,表示当前节点p是头结点，节点p拿掉后，p的下一个节点a就是头节点了；
* 否则将节点b的后一个节点设置为节点a
*/
if (b == null)
head = a;
else
b.after = a;
/**
* 因为将当前节点p拿掉了，那么节点a和节点b之间断开了，我们站在节点a的角度建立与节点b
* 的关联，如果节点a为null,表示当前节点p为尾结点，节点p拿掉后，p的前一个节点b为尾结点，
* 但是此时我们并没有直接将节点p赋值给tail,而是给了一个局部变量last(即当前的最后一个节点)，因为
* 直接赋值给tail与该方法最终的目标并不一致；如果节点a不为null将节点a的前一个节点设置为节点b
*
* （因为前面已经判断了(last = tail) != e，说明传入的节点并不是尾结点，既然不是尾结点，那么
* e.after必然不为null，那为什么这里又判断了a == null的情况？
* 以我的理解，java可通过反射机制破坏封装，因此如果都是反射创建出的Entry实体，可能不会满足前面
* 的判断条件）
*/
if (a != null)
a.before = b;
else
last = b;
/**
* 正常情况下last应该也不为空，为什么要判断，原因和前面一样
* 前面设置了p.after为null,此处再将其before值设置为上一次的尾结点last,同时将上一次的尾结点
* last设置为本次p
*/
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
//最后节点p设置为尾结点，完事
tail = p;
++modCount;
}
}
我们前面说到的linkNodeLast(Entry e)方法和现在的afterNodeAccess(Node e)都是将传入的Node节点放到最后，那么它们的使用场景如何呢？
在前面讲解HashMap时，提到了HashMap的put流程，如果在对应的hash位置上还没有元素，那么直接new Node()放到数组table中，这个时候对应到LinkedHashMap中，调用了newNode()方法，就会用到linkNodeLast()，将新node放到最后，而如果对应的hash位置上有元素，进行元素值的覆盖时，就会调用afterNodeAccess()，将原本可能不是最后的node节点拿到了最后。如
LinkedHashMap<String, Integer> map = new LinkedHashMap<>(16, 0.75f, true);
map.put("1月", 20);
//此时就会调用到linkNodeLast()方法，也会调用afterNodeAccess()方法，但会被阻挡在
//if (accessOrder && (last = tail) != e) 之外
map.put("2月", 30);
map.put("3月", 65);
map.put("4月", 43);
//这时不会调用linkNodeLast()，会调用afterNodeAccess()方法将key为“1月”的元素放到最后
map.put("1月", 35);
//这时不会调用linkNodeLast()，会调用afterNodeAccess()方法将key为“2月”的元素放到最后
map.get("2月");
//调用打印方法
for (Map.Entry<String, Integer> entry : map.entrySet()){
System.out.println("key: " + entry.getKey() + ", value: " + entry.getValue());
}
结果如下：
key: 3月, value: 65
key: 4月, value: 43
key: 1月, value: 35
key: 2月, value: 30
而如果是执行下面这段代码，将accessOrder改为false
LinkedHashMap<String, Integer> map = new LinkedHashMap<>(16, 0.75f, false);
map.put("1月", 20);
//此时就会调用到linkNodeLast()方法，也会调用afterNodeAccess()方法，但会被阻挡在
//if (accessOrder && (last = tail) != e) 之外
map.put("2月", 30);
map.put("3月", 65);
map.put("4月", 43);
//这时不会调用linkNodeLast()，会调用afterNodeAccess()方法将key为“1月”的元素放到最后
map.put("1月", 35);
map.get("2月");
//调用打印方法
for (Map.Entry<String, Integer> entry : map.entrySet()){
System.out.println("key: " + entry.getKey() + ", value: " + entry.getValue());
}
结果如下：
key: 1月, value: 35
key: 2月, value: 30
key: 3月, value: 65
key: 4月, value: 43
大家看到区别了吗，accessOrder为false时，你访问的顺序就是按照你第一次插入的顺序；而accessOrder为true时，你任何一次的操作，包括put、get操作，都会改变map中已有的存储顺序。
3. afterNodeInsertion方法
我们看到在LinkedHashMap中还重写了afterNodeInsertion(boolean evict)方法，它的目的是移除链表中最老的节点对象，也就是当前在头部的节点对象，但实际上在JDK8中不会执行，因为removeEldestEntry方法始终返回false。看源码：
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);
}
}
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
三. get方法
LinkedHashMap的get方法与HashMap中get方法的不同点也在于多了afterNodeAccess()方法
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;
}
在这里就不再多讲了，getNode()方法在HashMap章节已经讲过，而前面刚把afterNodeAccess讲了。
四.remove方法
remove方法也直接使用了HashMap中的remove，在HashMap章节并没有讲解，因为remove的原理很简单，通过传递的参数key计算出hash，据此可找到对应的Node节点，接下来如果该Node节点是直接在数组中的Node，则将table数组该位置的元素设置为node.next；如果是链表中的，则遍历链表，直到找到对应的node节点，然后建立该节点的上一个节点的next设置为该节点的next。
LinkedHashMap重写了其中的afterNodeRemoval(Node e)，该方法在HashMap中没有具体实现，通过此方法在删除节点的时候调整了双链表的结构。
void afterNodeRemoval(Node<K,V> e) {
LinkedHashMap.Entry<K,V> p = (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
//将待删除节点的before和after都设置为null
p.before = p.after = null;
/**
* 如果节点b为null，表示待删除节点p为头部节点，该节点拿掉后，该节点的下一个节点a就为头部节点head
* 否则设置待删除节点的上一个节点b的after属性为节点a
*/
if (b == null)
head = a;
else
b.after = a;
/**
* 如果节点a为null，表示待删除节点p为尾部节点，该节点拿掉后，该节点的上一个节点a就为尾部节点tail
* 否则设置待删除节点的下一个节点a的before属性为节点b
*/
if (a == null)
tail = b;
else
a.before = b;
}
五. 总结
LinkedHashMap使用的也较为频繁，它基于HashMap，用于HashMap的特点，又增加了双链表的结构，从而保证了顺序性，本文主要从源码的角度分析其如何保证顺序性，accessOrder的解释，以及常用方法的阐释，若有不对之处，请批评指正，望共同进步，谢谢！