一、简介
LinkedHashMap 继承了 HashMap 类，是 HashMap 的子类，LinkedHashMap 的大多数方法的实现直接使用了父类 HashMap 的方法。LinkedHashMap 可以说是 HashMap 和 LinkedList 的结合体，既使用了 HashMap 的数据结构，又借用了 LinkedList 双向链表的结构。
LinkedHashMap 实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双向链表。此链表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。
注意，此实现不是同步的。如果多个线程同时访问链接的哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。
二、继承结构
LinkedHashMap 继承了 HashMap 类，有着和 HashMap 类似的操作。
三、属性
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>
{
private static final long serialVersionUID = 3801124242820219131L;
transient LinkedHashMap.Entry<K,V> head;
transient LinkedHashMap.Entry<K,V> tail;
final boolean accessOrder;
}
在 HashMap 的基础上，LinkedHashMap 新增了 head 和 tail 属性，表示指向链表的头节点和尾节点。accessOrder 表示按访问顺序遍历还是按插入顺序遍历，如果 accessOrder 为 true，表示按访问顺序遍历，如果为 false，表示按插入顺序遍历。
四、构造方法
LinkedHashMap 有 5 种构造方法，大部分都在内部调用父类 HashMap 的构造方法。
public LinkedHashMap() {
super();
accessOrder = false;
}
无参构造方法表示用默认的初始化容量和负载因子创建一个 LinkedHashMap，以插入顺序取得键值对。
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
一个参数的构造方法表示构造一个指定初始容量的 LinkedHashMap，以插入顺序取得键值对。
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
两个参数的构造方法表示构造一个指定初始容量和负载因子的 LinkedHashMap，以插入顺序取得键值对。
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
三个参数的构造方法表示根据指定容量、装载因子和键值对保持顺序创建一个 LinkedHashMap。
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
该构造方法通过传入的 map 创建一个 LinkedHashMap，容量为默认容量和 map.size() / DEFAULT_LOAD_FACTORY + 1 的较大者，装载因子为默认值。
五、常用方法
0x01、put(K key, V value)
LinkedHashMap 的 put() 方法沿用了父类 HashMap 的 put() 方法，但我们也提到了像 LinkedHashMap 的 Entry 类就是继承了 HashMap 的 Node 类，同样的，HashMap 的 put() 方法中调用的其他方法在 LinkedHashMap 中已经被重写。
- newNode(int hash, K key, V value, Node<K,V> e)
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;
}
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;
}
}
LinkedHashMap 重写了 newNode() 方法，通过此方法保证了插入的顺序性。
- 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.after 设置为 null，断开了与后一个节点的关系，但还未确定其位置
p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a != null)
a.before = b;
else
last = b;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
// 将节点 p 设置为尾节点
tail = p;
++modCount;
}
}
关于 afterNodeAccess() 方法，在 HashMap 中没给具体实现，而在 LinkedHashMap 重写了，目的是保证操作过的 Node 节点永远在最后，从而保证读取的顺序性，在调用 put() 方法和 get() 方法时都会用到。
- afterNodeInsertion(boolean evict)
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;
}
我们看到在 LinkedHashMap 中还重写了 afterNodeInsertion(boolean evict) 方法，它的目的是移除链表中最老的节点对象，也就是当前在头部的节点对象，但实际上在 JDK 8 中不会执行，因为 removeEldestEntry() 方法始终返回 false。
0x02、get(Object key)
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;
}
LinkedHashMap 的 get() 方法与 HashMap 中 get() 方法的不同点在于多了 afterNodeAccess() 方法，afterNodeAccess() 方法在上文已经讲过。
0x03、remove(Object key)
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> 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<K,V>)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<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
remove() 方法也直接使用了 HashMap 中的 remove()，在 HashMap 章节中并没有讲解，因为 remove() 的原理很简单，通过传递的参数 key 计算出 hash，据此可找到对应的 Node 节点，如果该 Node 节点是直接在数组中的 Node，则将 table 数组该位置的元素设置为 node.next，如果是链表中的，则遍历链表，直到找到对应的 Node 节点，然后将该节点的上一个节点的 next 设置为该节点的 next。
void afterNodeRemoval(Node<K,V> e) { // unlink
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
if (b == null)
// 表示待删除节点 p 为头部节点，该节点拿掉后，该节点的下一个节点 a 就为头部节点 head
head = a;
else
// 否则设置待删除节点的上一个节点 b 的 after 属性为节点 a
b.after = a;
// 如果节点 a 为 null
if (a == null)
// 表示待删除节点 p 为尾部节点，该节点拿掉后，该节点的上一个节点 a 就为尾部节点 tail
tail = b;
else
// 否则设置待删除节点的下一个节点 a 的 before 属性为节点 b
a.before = b;
}
LinkedHashMap 重写了其中的 afterNodeRemoval(Node e)，该方法在 HashMap 中没有具体实现，通过此方法在删除节点的时候调整了双链表的结构。
六、总结
-
LinkedHashMap 继承于 HashMap，是基于 HashMap 和双向链表来实现的。
-
HashMap 无序，LinkedHashMap 有序，可分为插入顺序和访问顺序两种。如果是访问顺序，那 put() 和 get() 操作已存在的 Entry 时，都会把 Entry 移动到双向链表的表尾（其实是先删除再插入）。
-
LinkedHashMap 存取数据，还是跟 HashMap 一样使用的 Entry[] 的方式，双向链表只是为了保证顺序。
-
LinkedHashMap 是线程不安全的。
参考
https://www.cnblogs.com/LiaHon/p/11180869.html
https://www.jianshu.com/p/8f4f58b4b8ab
187
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
