一、LinkedHashMap
1.1 数据结构示意图
来源网络
由上图可以看出LinkedHashMap的底层类似于HashMap，不过它还维护了一个双向链表。这就保证了它的插入顺序。也就是说说默认情况下，遍历是按照插入节点的顺序。但是在构造时候传入accessOrder参数（默认时是false），使得其遍历顺序按照访问的顺序输出(在调用get方法后，会把当前的元素移动到链表的末尾)。
1.2 成员变量
/**
* The head (eldest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> head;
/**
* The tail (youngest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> tail;
/**
* 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;
head 、tail 分别指向内部双向链表的表头和表尾，accessOrder指定了遍历时的顺序(在AccessOrder的情况下，使用get方法也是结构性的修改！使用它获取value会出现运行时修改的异常)
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节点，但是在其基础上进行了拓展，改成了一个双向链表。
1.3 构造函数
//默认是false，则迭代时输出的顺序是插入节点的顺序。若为true，则输出的顺序是按照访问节点的顺序。
//为true时，可以在这基础之上构建一个LruCach
final boolean accessOrder;
public LinkedHashMap() {
super();
accessOrder = false;
}
//指定初始化时的容量，
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
//指定初始化时的容量，和扩容的加载因子
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
//指定初始化时的容量，和扩容的加载因子，以及迭代输出节点的顺序
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
//利用另一个Map 来构建，
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
//该方法上文分析过，批量插入一个map中的所有数据到 本集合中。
putMapEntries(m, false);
}
与HashMap的基本相同，但是增加了一个accessOrder变量，规定了遍历时的访问顺序，默认是按插入顺序。
1.4 重写HashMap的方法
//将LinkedHashMap重置到默认状态
void reinitialize() {
super.reinitialize();//重置哈希表
head = tail = null;//重置双链表
}
//创建一个普通entry，将entry插入到双向循环链表的末尾,最后返回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;
}
//将新增的节点，连接在链表的尾部
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;
}
}
1.5 put方法
在源码中并没有找到put。LinkedHashMap继承自HashMap，它直接使用了HashMap的put方法，但是在创建节点时，它调用的是自己重写的newNode（...）方法（见上面）
1.6 get 方法
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;//根据键的hash值调用getNode寻找节点，如过不存在，返回null；
if (accessOrder)//如果是访问顺序，将这个节点放到链表的末尾，
afterNodeAccess(e);
return e.value;//否则返回这个节点的值
}
//将这个节点放到链表的末尾
void afterNodeAccess(Node<K,V> e) { // move node to last
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;
}
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
getNode方法获取节点（与HashMap的一样 ）：
- 如果第一个就匹配上了，直接返回
- 否则，判断节点类型是否是红黑树，是就遍历树
- 否则就是链表了，遍历
- 最后返回
1.7 remove方法
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
类似于HashMap的removeNode，但是里面有调用重写的afterNodeRemoval（...）,保证了元素删除后，hash表和链表的一致性
//在删除节点e时，同步将e从双向链表上删除
void afterNodeRemoval(Node<K,V> e) { // unlink
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
//待删除节点 p 的前置后置节点都置空
p.before = p.after = null;
//如果前置节点是null，则现在的头结点应该是后置节点a
if (b == null)
head = a;
else//否则将前置节点b的后置节点指向a
b.after = a;
//同理如果后置节点时null ，则尾节点应是b
if (a == null)
tail = b;
else//否则更新后置节点a的前置节点为b
a.before = b;
}
1.8 遍历
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
//返回LinkedEntrySet
return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es;
}
}
image.png
image.png
image.png
由上可以知道在使用迭代器时，从内部维护的双链表的表头开始循环输出，这就说明了初始容量对遍历没有影响
二、小结
LinkedHashMap继承了HashMap，它的大部分方法都是直接拿过来使用的。与HashMap最大的不同就是通过内部维护的双向链表可以保证了插入顺序。增加的accessOrder变量可以改变它迭代遍历时的顺序。在每次插入数据，或者访问、修改数据时，会增加节点、或调整链表的节点顺序。以决定迭代时输出的顺序。
- accessOrder默认是false，则迭代时输出的顺序是插入节点的顺序。若为true，则输出的顺序是按照访问节点的顺序。（将当前被访问的节点移动到双向链表的尾部）
- 没有重写put方法，但是内部重写了newNode（...），保证新建节点时将其插入到双向链表的尾部
- 重写了entrySet（）方法。里面的迭代器的next（）方法会从内部尾部的双向链表的表头循环输出。
参考：
网友评论