目录
一.介绍
1.1 HashMap无法保证顺序
1.2 如何保证HashMap的顺序
1.3 使用LinkedHashMap
2.2 链表的节点类型
2.3 新增的属性
2.4 构造方法
2.6.1 afterNodeAccess
2.6.2 afterNodeInsertion
2.6.3 afterNodeRemoval
2.6.3 internalNodeWrit
三. 总结
一.介绍
1.1 HashMap无法保证顺序
对于HashMap而言，将数据放入其中后，如果我们需要遍历map中的所有元素，可以这么做：
1.通过map.entrySet()来获取包含所有数据的set，对该set进行遍历；
2.通过map.keySet()获取所有的key，然后遍历key，调用get方法获取value；
上面这两种方式都是可以进行map元素的遍历，但是同时也存在一个问题：数据的顺序无法保证，也就是说，在打印出所有元素前，元素的顺序是未知的。
1.2 如何保证HashMap的顺序
因为HashMap不能保证顺序，就需要借助其他的数据结构，比如可以额外使用一个List（比如ArrayList），每次加入map后，同时再加入ArrayList，如果需要顺序遍历数据，则直接遍历ArrayList即可，就不用遍历map了。
但是这样的话，开销就会相对较高，首先需要创建ArrayList，还需要每次增删元素后，都要对ArrayList进行操作（移动元素），时间复杂度O(n），空间复杂度O(n)。
1.3 使用LinkedHashMap
上面使用ArrayList来保证数据的顺序性，当元素发生变化时，就需要移动ArrayList中的元素，时间复杂度O（n），空间复杂度为O（n），那么如果可以降低时间复杂度和空间复杂度就好了。
于是，就会联想到链表，不考虑查找元素的开销，增删元素的时间复杂度为O(1)；但是还是需要O(n)的空间复杂度，因为需要保存节点值，如果能把空间复杂度降下来就好了，此时就可以了解一下LinkedHashMap。
LinkedHashMap，其实从名字上就可以看出他是功能，Linked+HashMap，说到Linked，自然就会联系到LinkedList，所以，LinkedhashMap可以简单的理解为LinkedList+HashMap。
需要注意的是，LinkedHashMap并没有完全创建一个新的节点类型，而是在HashMap的Node内部类上进行扩充，增加前后指针，这样也是可以节省很多空间的。
1.4 LinkedHashMap的顺序分类
LinkedHashMap可以保证HashMap元素的顺序，这个顺序，有两种：
1.遍历元素的顺序与插入元素的顺序一致，也就是说，依次插入A->B->C，那么遍历时的顺序就是A->B->C;
2.初始时，遍历元素的顺序与插入的顺序一致，但是当元素被范文，也就是说，插入A->B->C后，遍历的顺序是A->B->C；如果中间访问访问或者修改过B，那么顺序就会变为A->C->B，
在LinkedHashMap中，有一个accessOrder属性来设定是否按照访问顺序来遍历，默认为false，也就是上面默认使用第一种方式。
1.5 LinkedHashMap使用示例
package cn.ganlixin.util;
import org.junit.Test;
import java.util.LinkedHashMap;
import java.util.Map;
public class TestLinkedHashMap {
/**
* 遍历顺序和插入顺序相同，期间访问或者修改元素，顺序不会发生改变
*/
@Test
public void testNormal() {
Map<String, String> map = new LinkedHashMap<>();
map.put("one", "1111");
map.put("two", "2222");
map.put("three", "3333");
for (Map.Entry entry : map.entrySet()) {
System.out.println(entry.getKey() + "=>" + entry.getValue());
}
/** 输出如下：
one=>1111
two=>2222
three=>3333
*/
map.put("two", "2");
for (Map.Entry entry : map.entrySet()) {
System.out.println(entry.getKey() + "=>" + entry.getValue());
}
/** 输出如下：
one=>1111
two=>2222
three=>3333
*/
}
/**
* 遍历顺序为访问（修改）顺序，元素被访问或者被修改后，会移到最后
*/
@Test
public void testAccessOrder() {
// public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)
Map<String, String> map = new LinkedHashMap<>(16, 0.75f, true);
// 创建map时，设置遍历顺序按照访问顺序
map.put("one", "1111");
map.put("two", "2222");
map.put("three", "3333");
for (Map.Entry entry : map.entrySet()) {
System.out.println(entry.getKey() + "=>" + entry.getValue());
}
/**
one=>1111
two=>2222
three=>3333
*/
map.get("one"); // 某个元素访问后，会将该元素移动到末尾
for (Map.Entry entry : map.entrySet()) {
System.out.println(entry.getKey() + "=>" + entry.getValue());
}
/**
two=>2222
three=>3333
one=>1111
*/
map.put("two", "2"); // 修改元素后，也会将元素移动到最后
for (Map.Entry entry : map.entrySet()) {
System.out.println(entry.getKey() + "=>" + entry.getValue());
}
/**
three=>3333
one=>1111
two=>2
*/
map.replace("three", "3"); // 修改元素后，也会将元素移动到最后
for (Map.Entry entry : map.entrySet()) {
System.out.println(entry.getKey() + "=>" + entry.getValue());
}
/**
three=>3333
one=>1111
two=>2
*/
}
}
二.LinkedHashMap源码解析
2.1 LinkedHashMap原理概览
在阅读LinkedHashMap前，要先了解HashMap的原理，可以参考：HashMap源码解析-Java8，方便后面对LinkedHashMap源码的理解。
LinkedHashMap继承自HashMap，也就是说HashMap的功能，LinkedHashMap都支持。
public class LinkedHashMap<K, V> extends HashMap<K, V> implements Map<K, V>
LinkedHashMap对HashMap的部分API进行了重写，以此来保证map中元素遍历时的顺序。通过第一部分的一些介绍，其实我们大概才出LinkedHashMap是如何保证顺序的：
1.对于遍历顺序与插入顺序相同的情况，只需要在将元素put到双链表后，维护节点的指针，链入上一次put的节点后面（成为尾结点）；
2.对于遍历顺序与访问顺序相同一致的情况，只需要在get、put、replace..操作之后，将节点移动到末尾即可。
2.2 双链表的节点
LinkedHashMap中双链表的节点类型，是直接在HashMap的节点类型上进行扩充的，增加了before和after指针；
/**
* 链表的节点类型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);
}
}
2.3 新增属性
LinkedHashMap继承自HashMap，也继承了HashMap中的所有属性，比如默认的初始容量、默认的负载因子、默认转换为红黑树和链表的阈值...
除此之前，LinkedHashMap增加了3个额外的属性，其中两个属性用于实现双链表的头尾节点，另外一个属性用于控制顺序的类型：
/** * 指向双链表的头结点（如果map为空=>双链表为空=>head为空） */ transient LinkedHashMap.Entry<K, V> head; /** * 指向双链表的尾结点（如果map为空=>双链表为空=>tail为空） */ transient LinkedHashMap.Entry<K, V> tail; /** * 设置LinkedHashMap的顺序类型 * false：表示遍历元素的顺序与插入顺序相同 * true：表示遍历元素的顺序按照访问的顺序排列，当一个数据被访问（修改）后，该数据就会移动到最后 */ final boolean accessOrder;
2.4构造方法
LinkedHashMap的构造方法，其实主要有两个点：1.设置HashMap的初始容量和负载因子；2.设置顺序类型（accessOrder）。
/**
* 创建LinkedHashMap，使用HashMap默认的初始容量16，默认的负载因子0.75
*/
public LinkedHashMap() {
super();
accessOrder = false;
}
/**
* 创建LinkedHashMap，指定HashMap的初始容量，使用默认的负载因子0.75
*/
public LinkedHashMap(int initialCapacity) {
// 指定HashMap的初始容量
super(initialCapacity);
accessOrder = false;
}
/**
* 创建LinkedHashMap，指定HashMap的初始容量和负载因子
*/
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
/**
* 创建LinkedHashMap，指定HashMap初始容量和负载因子，以及是否顺序获取
*/
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
/**
* 创建LinkedHashMap，使用HashMap默认的初始容量(16)和负载因子(0.75)
* 并且将传入的map放入到LinkedHashMap中
*/
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
2.5 LinkedHashMap的put
LinkedHashMap并没有覆盖HashMap的put方法，而是直接沿用HashMap的put方法。
那么LinkedHashMap是如何保证顺序的呢？
是这样的，HashMap在put的时候：
1.如果是新增节点，那么就会创建一个节点，然后放入到map中；
2.如果put操作时修改操作（也就是put的key已经存在），那么不需要创建节点，只需要修改已有节点的value即可；
对于第一种情况，创建节点，是HashMap和LinkedHashMap都有的，LinkedHashMap重写了HashMap创建新节点的方法（newNode和newTreeNode两个方法），在这个时候将新创建的节点加入链表的末尾：
/**
* HashMap的newNode，创建一个Node节点
*/
Node<K, V> newNode(int hash, K key, V value, Node<K, V> next) {
return new Node<>(hash, key, value, next);
}
/**
* HashMap中的newTreeNode，创建一个红黑树的节点
*/
TreeNode<K, V> newTreeNode(int hash, K key, V value, Node<K, V> next) {
return new TreeNode<>(hash, key, value, next);
}
/**
* LinkedHashMap重写HashMap的newNode方法，
* 创建一个双链表节点，同时将新节点作为双链表的尾结点
*/
@Override
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;
}
/**
* LinkedHashMap重写HashMap的newTreeNode方法
* 创建一个红黑树的节点，并将节点加入到双链表的最后
*/
@Override
TreeNode<K, V> newTreeNode(int hash, K key, V value, Node<K, V> next) {
TreeNode<K, V> p = new TreeNode<K, V>(hash, key, value, next);
// 将新创建的节点加入链表尾部
linkNodeLast(p);
return p;
}
/**
* 将节点加入链表中（挂在最后位置）
*/
private void linkNodeLast(LinkedHashMap.Entry<K, V> p) {
// tail指向的尾结点
LinkedHashMap.Entry<K, V> last = tail;
tail = p;
if (last == null) {
// last==null，证明插入节点前链表为空，此时head也需要指向p
head = p;
} else {
// 插入节点前，链表不为空，维护指针关系，将p插入到最后
p.before = last;
last.after = p;
}
}
对于put方法，进行了替换操作，就需要用到后面说的一些post-actions（后置处理）来完成顺序的保证。
2.6 some post-actions
由于LinkedHashMap是继承自HashMap，并且大部分的代码都没有做更改，也就是直接沿用HashMap的接口。那么LinkedHashMap是如何保证顺序的呢？特别是前面说的保证插入的顺序，保证访问的顺序？？
其实HashMap的一些API中，比如put方法，其中就包含了一些callback，当插入元素或者查找到元素后，就调用某个方法；这些callback方法在HashMap中没有进行任何操作（方法体为空），留给子类LinkedHashMap进行实现的，如下面所示：
// Callbacks to allow LinkedHashMap post-actions
/**
* 当节点被访问后调用，比如
*
* @param p 被访问的节点
*/
void afterNodeAccess(Node<K, V> p) {
}
/**
* 当元素添加到map后，执行的操作
* @param evict
*/
void afterNodeInsertion(boolean evict) {
}
/**
* 当元素被移除后，执行的操作
* @param p 被移除的节点
*/
void afterNodeRemoval(Node<K, V> p) {
}
2.6.1 afterNodeAccess
afterNodeAccess方法，是在元素节点被访问之后被调用，主要是以下几种（一部分）：
1.get操作
2.put操作，如果是替换，那么就会先查找是否存在已有节点，若发现已经存在该节点（则该节点被访问），就会回调afterNodeAccess方法；
3.遍历操作
在LinkedHashMap中afterNodeAccess，主要执行的就是将元素移动到链表的最后，前提是accessOrder为true（在访问元素后，就将元素移动到链表移动到最后）。
/**
* accessOrder为true时，表示map中元素保持和访问的顺序相同
* 所以需要将访问的节点移动到双链表的末尾
*
* @param e 包含元素最新值的Node节点
*/
void afterNodeAccess(Node<K, V> e) { // move node to last
LinkedHashMap.Entry<K, V> last;
// accessOrder为true，表示map中数据的顺序按照访问顺序排序
// 如果e不是最后一个元素才进行操作（因为
if (accessOrder && (last = tail) != e) {
// p指向e，b指向e的前继节点，a指向e的后继节点
LinkedHashMap.Entry<K, V> p = (LinkedHashMap.Entry<K, V>) e, b = p.before, a = p.after;
// 将p的后继设为null（因为要将其设为尾结点，尾结点的after为null）
p.after = null;
if (b == null) {
// e的前继节点为null，证明e为头结点，则将e的后继节点设置为新头结点
head = a;
} else {
// e不是头结点，则将e的后继节点设置为前继节点的后继节点
b.after = a;
}
if (a != null) {
// e节点不是尾结点，那么就将e的前继节点设置为后继节点的前继节点
a.before = b;
} else {
// e的后继节点为null，证明e为尾结点，则将e的前继节点设置为尾结点
last = b;
}
if (last == null) {
// 如果修改指针关系（删除e后），last为null，也就是尾结点为null，证明链表为空了
// 此时将p节点（也就是e节点）作为头结点
head = p;
} else {
// 链表不为null，则将e节点挂到最后
p.before = last;
last.after = p;
}
// tail指针指向e节点
tail = p;
// 修改次数加1
++modCount;
}
}
2.6.2 afterNodeInsertion
afterNodeInsertion方法，是在HashMap的put和putAll方法调用后执行的，主要做的就是删除链表的头结点。
在LinkedHashMap中，默认是不会每次删除头结点的，如果需要加入节点后进行删除头结点，则需要另外创建子类进行实现逻辑。
上面提到一个eldestEntry，也就是最老的Entry，其实也就是链表的头结点（accessOrder=false->最早插入，accessOrder=true->最久未访问）。
2.6.3 afterNodeRemoval
当调用LinkedHashMap的remove接口，其实也就是调用HashMap的remove接口（LinkedHashMap没有重写该接口）。
在HashMap中移除元素后，会回调afterNodeRemoval方法，该方法在HashMap中并做任何操作，而是留给子类LinkedHashMap进行定义对应的操作，LinkedHashMap做的就是维护链表指针，将删除的元素从链表中删除。
/**
* LinkedHashMap删除元素后，维护链表间的指针关系，将节点从双链表中删除
*/
@Override
void afterNodeRemoval(Node<K, V> e) { // unlink
LinkedHashMap.Entry<K, V> p = (LinkedHashMap.Entry<K, V>) e, b = p.before, a = p.after;
p.before = p.after = null;
if (b == null) {
// b为e的前继节点，如果前继节点为null，证明e为头结点，则将第二个节点（e的后继）作为新的头结点
head = a;
} else {
// e不是头结点，维护前继和后继的关系
b.after = a;
}
if (a == null) {
// 后继节点为空，表示e为尾结点，此时将e的前继节点b作为尾结点
tail = b;
} else {
// e不是尾结点，则前继和后继的关系
a.before = b;
}
}
2.6.4 internalWriteEntries
当序列化map的时候（使用ObjectOutputStream），会调用HashMap中的writeObject方法
/**
* 调用ObjectOutputStream来序列化map时，会调用writeObject方法
*/
private void writeObject(java.io.ObjectOutputStream s) throws IOException {
int buckets = capacity();
// 将一些属性写入到流中
s.defaultWriteObject();
s.writeInt(buckets);
s.writeInt(size);
// 将数据写入
internalWriteEntries(s);
}
/**
* HashMap中的实现，将map中的数据顺序写入
*/
void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
Node<K, V>[] tab;
// 如果map不为空，则遍历数组的每个位置进行操作
if (size > 0 && (tab = table) != null) {
for (int i = 0; i < tab.length; ++i) {
// 每个位置可能是链表或者红黑树结构，则进行遍历时写入
for (Node<K, V> e = tab[i]; e != null; e = e.next) {
s.writeObject(e.key);
s.writeObject(e.value);
}
}
}
}
internalWriteEntries方法，就是在输出的时候决定数据的顺序，可以看到上面是HashMap的internalWriteEntries方法，是依次遍历数组的每个位置，然后遍历每个位置上的链表或者红黑树，这个时候顺序并没有什么规律。
而LinkedHashMap，只是重写了internalWriteEntries方法，在其中对顺序进行调整：
/**
* LinkedHashMap中的实现
*/
void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
// 遍历双链表，从头到尾进行遍历，保证了顺序
for (LinkedHashMap.Entry<K, V> e = head; e != null; e = e.after) {
s.writeObject(e.key);
s.writeObject(e.value);
}
}
2.7 LinkedHashMap.get方法
/**
* 获取key对应的值
*/
public V get(Object key) {
Node<K, V> e;
// 调用HashMap中的getNode
if ((e = getNode(hash(key), key)) == null) {
return null;
}
// 如果设置的顺序是按照访问顺序，那么就需要在访问节点后，将节点移到末尾
if (accessOrder) {
afterNodeAccess(e);
}
return e.value;
}
三.总结
其实对于LinkedHashMap，没有太多的需要阐述的，更多的应该是看HashMap，因为维护节点顺序的操作都是在HashMap中进行回调的。
简单理解LinkedHashMap，也就是利用双链表数据结构，在HashMap的Node节点类型上增加前后指针，每次访问或者修改节点后，会回调相关的callback，进行节点顺序的维护。节点的顺序可以分为插入顺序和访问顺序，通过accessOrder进行控制。
四.常见的面试题
一般是问LinkedHashMap的原理，比如：
1.节点类型
2.底层是双链表还是单链表
3.节点的顺序（accessOrder）
4.几个扩展点（afterNodeAccess、afterNodeInsertion、afterNodeRemoval）
而关于节点的顺序，如果时间长了，可能会忘记，这里简单记一下：
对于accessOrder为false，也就是默认情况下，遍历时元素的顺序只与插入的顺序有关；如果某个key对应的数据已经存在，再次put、replace该key后，元素的顺序不会发生改变。
对于accessOrder为true，将元素加入map后：
1.在没有访问的情况下，遍历map元素，顺序与插入顺序一致；
2.访问元素（access），包括get、put、replace操作，无论是替换还是新增，元素都将移动到最后！！