文章目录
继承体系
继承HashMap，在其基础上记录插入顺序。
简介
LinkedHashMap具有可预测的迭代顺序，与HashMap的不同之处在于，它维护一个遍历所有条目的双向链接列表。此链表定义了迭代顺序，通常是将键插入映射中的顺序。请注意，如果将键重新插入到地图中，则插入顺序不会受到影响。
非线程安全，支持快速失败
我们知道HashMap是 数组+链表+红黑树，LinkedHashMap继承了它，内部也是这样的结构，只是在每次插入节点时，记录节点前后的节点。
属性
//双向队列的队头
transient LinkedHashMap.Entry<K,V> head;
//双向队列的队尾
transient LinkedHashMap.Entry<K,V> tail;
//定义hash表迭代方式 true：访问顺序，false：插入顺序
final boolean accessOrder;
内部类
//扩展node节点 加before，after记录前后节点
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);
}
}
构造方法
//调用父类无参构造 使用默认加载因子和容量
public LinkedHashMap() {
super();
accessOrder = false;
}
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
//初始化后 插入map集合数据
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
public LinkedHashMap(int initialCapacity,
float loadFactor, boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
关键方法解析
LinkedHashMap有两种顺序，插入顺序和访问顺序，默认插入顺序。
先来看看它是怎么记录插入顺序的
插入顺序实现
既然是记录插入顺序，那么就要在put方法操作后修改双向链表。然而LinkedHashmap中没有put，使用的HashMap的put方法，这从何入手找到它的切入点呢？
其实呢，HashMap的方法put时要有一个‘节点’，那么只需要在创建节点的方法里面处理顺序就可以了，LinkedHashMap重写了节点创建方法。
newNode
-- 注意这里的linkNodeLast(p)方法
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;
}
newTreeNode
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;
}
linkNodeLast
-- 将节点双向链表最后
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;//将当前最后节点取出
tail = p;//尾节点指向即将成为最后节点的p
if (last == null)//说明是初始化 将p放入头
head = p;
else {//加入双向链表最后
p.before = last;
last.after = p;
}
}
访问顺序实现
既然是访问，那必然是调用了get方法，LinkedHashMap重写了get方法
get
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;
}
afterNodeAccess
-- 将节点移到最后
void afterNodeAccess(Node<K,V> e) {
LinkedHashMap.Entry<K,V> last;
if (accessOrder && (last = tail) != e) {
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
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;
}
tail = p;
++modCount;
}
}
HashMap为LinkedHashMap做的钩子
// LinkedHashMap后处理的回调
// 这些方法HashMap没有实现 但是在添加、获取、移除后调用了
// 那么LinkedHashMap那边实现后 当添加后回调这些方法处理双向链表
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
移除旧元素
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
这个方法没有实现，在插入数据后调用了
继承此类，重写这个方法，可以做缓存，默认并不会移除旧元素
看下面这个jdk中类的缓存实现
总结
（1）LinkedHashMap继承自HashMap，具有HashMap的所有特性；
（2）LinkedHashMap内部维护了一个双向链表存储所有的元素；
（3）如果accessOrder为false(默认)，按插入顺序遍历元素、为true按访问顺序遍历元素；
（4）默认的LinkedHashMap并不会移除旧元素，如果需要移除旧元素，则需要重写removeEldestEntry()方法设定移除策略；