本文详细解析了LinkedHashMap的结构和源码，阐述了其在HashMap基础上增加的双向链表设计，保证了元素的插入顺序和迭代顺序。通过分析构造方法、put、remove和get方法，展示了LinkedHashMap如何维护元素顺序，并对比了与HashMap的差异。
一、LinkedHashMap解读
LinkedHashMap类的层次结构：
LinkedHashMap实现了Map<K,V>接口，继承HashMap类。
LinkedHashMap继承自HashMap，底层数据结构大体相似，都有数组+单向链表+红黑树，LinkedHashMap在此数据结构上新添加维护了一条双向链表，把所有的元素通过双向链表连接起来，比HashMap多了元素的顺序（添加顺序）。所以可以说linkedHashMap的数据结构为：数组+单向链表+红黑树+双向链表。添加了双向链表虽然增加了时间和空间上的开销，但是通过维护一个运行于所有元素的双向链表，使得linkedHashMap保证了元素的添加顺序和迭代顺序。LinkedHashMap绝大部分方法都是继承自父类HashMap，比如关键的put(k,v)方法，仅为维护双向链表覆写了部分方法。但LinkedHashMap的5个构造方法内部也是通过super关键字调用父类HashMap构造方法来做初始化。所以，建议要看LinkedHashMap源码的话先读懂HashMap源码，彻底了解其数据结构，可以参考上篇博客源码解析java集合框架，HashMap源码。
linkedHashMap结构如下：
二、源码解读
LinkedHashMap对元素的增删改查等操作大多基于其父类HashMap中的方法，只是实现的细节有所不同，而LinkedHashMap所做的是使用双向链表维护元素的插入顺序，在LinkedHashMap类源码中看不到put、remove等方法，都是直接使用父类HashMap中的方法。
2.1 构造方法
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false; //为false代表LinkedHashMap保持插入顺序
}
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
public LinkedHashMap() {
super();
accessOrder = false;
}
/**
* The iteration ordering method for this linked hash map: <tt>true</tt>
* for access-order, <tt>false</tt> for insertion-order.
* 为false代表保持插入顺序，true访问顺序
*/
final boolean accessOrder;LinkedHashMap构造方法内部都是super调用父类HashMap构造方法，HashMap构造方法只有给常量赋值操作，没有任何构建操作，如下其中一个：
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}2.2 添加元素put(k,v)方法
新建一个LinkedHashMap对象，调用put方法，会发现使用的是HashMap的put方法：
LinkedHashMap<String, String> lhm = new LinkedHashMap<>();
lhm.put("cn","china");HashMap中put(k,v)源码：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; //新建数组桶，未初始化
Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0) //当数组table为空时
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null) //根据hash值定位数组桶的位置，
//如果该位置为空，没有数据时，则使用传入的key、value、hash值新建Node对象，放置在该位置。
tab[i] = newNode(hash, key, value, null);
else { //当桶位置上有数据时
Node<K,V> e; K k;
//插入的元素与桶所在位置第一个元素相比，hash值相等，key相等时
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//hash值不相等或key不相等时
else if (p instanceof TreeNode) //判断是红黑树时
//把元素放入数中
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//第三种情况只有为链表
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {//下一个元素为null，即为链表末端时
p.next = newNode(hash, key, value, null);//末端插入元素
//链表节点数量到达阈值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;
}
}
//当在桶中找到key值、hash值与插入元素相等的元素时，覆盖元素的value值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//判断是否需要扩容，超过限定值则调用resize()方法扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}LinkedHashMap为了双链表的实现，重写了HashMap一些方法，供putVal()方法调用。
2.2.1 LinkedHashMap的newNode(h, k, v, null)方法
在putVal()方法中，有对方法newNode(h, k, v, null)的调用，新建桶中元素并放入桶中。LinkedHashMap重写了newNode(h, k, v, null)方法，重写如下：
//LinkedHashMap新建桶元素node
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;
}// link at the end of list
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;
}
}
/**
* The head (eldest) of the doubly linked list.
* LinkedHashMap双向链表头
*/
transient LinkedHashMap.Entry<K,V> head;
/**
* The tail (youngest) of the doubly linked list.
* LinkedHashMap双向链表尾
*/
transient LinkedHashMap.Entry<K,V> tail;再来看LinkedHashMap的Entry对象，LinkedHashMap每个节点都是一个Entry对象，它继承了HashMap.Node<K,V>，但比Node多了两属性Entry<K,V> before, after，用来存储前后元素，实现双链表：
/**
* HashMap.Node subclass for normal LinkedHashMap entries.
*/
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中包含了int hash、K k、V v、Node<K,V> next，实现了HashMap的单链表，LinkedHashMap.Entry在此基础上增加了前后两个指针域，形成双向链表，之前的单链表依然存在。
2.2.2 插入树元素时，LinkedHashMap同样进行了重写操作，重写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;
}2.2.3 afterNodeAccess()方法和afterNodeInsertion()方法
LinkedHashMap重写了afterNodeAccess和afterNodeInsertion方法，自己维护链表关系。
2.3 删除元素remove(Object key)方法
LinkedHashMap删除元素调用的也是父类HashMap的remove()方法：
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;
//如果数组tab不为空、长度大于0、根据hash值对应位置数据不为空
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;
//如果当前节点key和传入key相等，那么当前节点就是要删除的节点，赋值给node
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
//桶中元素未匹配上，需检查后面数据，有可能为树，有可能为链表
else if ((e = p.next) != null) {
//如果后面节点为树，则使用树获取节点方法匹配数据，返回给node
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
//不是数，则为链表，迭代匹配数据，匹配到返回给node
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);
}
}
//对node判断，node不为空，说明根据key匹配到了要删除的节点数据，
//删除node
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);
//如果该节点是桶中元素，则使用赋值node.next的方式删除该节点
else if (node == p)
tab[index] = node.next;
//是链表的话移动指针即可
else
p.next = node.next;
++modCount; //hashmap修改次数
--size; //hashmap元素个数
afterNodeRemoval(node);
return node;
}
}
return null;
}LinkedHashMap重写了afterNodeRemoval()方法，
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)
head = a;
else
b.after = a;
if (a == null)
tail = b;
else
a.before = b;
}这个方法是LinkedHashMap重新维护双向链表元素的前后关系。
2.4 获取元素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方法，但是getNode()方法还是调用的HashMap中的。LinkedHashMap中根据accessOrder的值来决定是否调用afterNodeAccess方法，为true，就会重新进行双向链表的维护优化，将最近一次访问的元素置于双向链表的尾部，作为缓存。
后语，LinkedHashMap可以说是HashMap的延伸，在HashMap的基础上加了双向链表，使得有了顺序，弥补了HashMap无序的不足，同时，在实现上基本是使用HashMap作为母体，只是针对双向链表做了自我实现。
与HashMap相比，LinkedHashMap在空间和时间上是劣势，但实现了有序。
扫一扫
898
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
