Java 容器 LinkedHashMap源码分析2

一、类签名

LinkedHashMap<K,V>继承自HashMap<K,V>，可知存入的节点key永远是唯一的。可以通过Android的LruCache了解LinkedHashMap用法。

1 public class LinkedHashMap<K,V>
2     extends HashMap<K,V>
3     implements Map<K,V>

二、节点

Entry<K,V>是HashMap.Node<K,V>的子类，增加before、after引用实现双向链表

1 static class Entry<K,V> extends HashMap.Node<K,V> {
2     // 前节点、后节点
3     Entry<K,V> before, after;
4 
5     Entry(int hash, K key, V value, Node<K,V> next) {
6         // 调用HashMap构造方法
7         super(hash, key, value, next);
8     }
9 }

三、数据成员

双向链表头，指向最早（最老）访问节点元素

transient LinkedHashMap.Entry<K,V> head; 

双向链表尾，指向最近（最晚）访问节点元素

transient LinkedHashMap.Entry<K,V> tail; 

是否保持访问顺序，为true则每次被访问的节点都会放到链表尾部

final boolean accessOrder;

依次插入Entry_0到Entry_5，当accessOrder为true并访问Entry_4时，Entry_4会被移到链尾

扫描二维码关注公众号，回复： 5933973 查看本文章

四、构造方法

 1 public LinkedHashMap(int initialCapacity, float loadFactor) {
 2     super(initialCapacity, loadFactor);
 3     accessOrder = false;
 4 }
 5 
 6 public LinkedHashMap(int initialCapacity) {
 7     super(initialCapacity);
 8     accessOrder = false;
 9 }
10 
11 public LinkedHashMap() {
12     super();
13     accessOrder = false;
14 }
15 
16 public LinkedHashMap(Map<? extends K, ? extends V> m) {
17     super();
18     accessOrder = false;
19     putMapEntries(m, false);
20 }
21 
22 // 维持存取顺序仅能通过此构造方法
23 public LinkedHashMap(int initialCapacity,
24                      float loadFactor,
25                      boolean accessOrder) {
26     super(initialCapacity, loadFactor);
27     this.accessOrder = accessOrder;
28 }

五、成员方法

 1 // 把节点插入到链表尾部
 2 private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
 3     LinkedHashMap.Entry<K,V> last = tail;
 4     tail = p;
 5     // 如果尾节点为空表明链表没有元素，则p就是头结点
 6     if (last == null)
 7         head = p;
 8     else {
 9         // 处理双向链表节点
10         p.before = last;
11         last.after = p;
12     }
13 }
14 
15 // apply src's links to dst
16 private void transferLinks(LinkedHashMap.Entry<K,V> src,
17                            LinkedHashMap.Entry<K,V> dst) {
18     LinkedHashMap.Entry<K,V> b = dst.before = src.before;
19     LinkedHashMap.Entry<K,V> a = dst.after = src.after;
20     if (b == null)
21         head = dst;
22     else
23         b.after = dst;
24     if (a == null)
25         tail = dst;
26     else
27         a.before = dst;
28 }
29 
30 // 重写HashMap钩子方法
31 void reinitialize() {
32     super.reinitialize();
33     head = tail = null;
34 }
35 
36 // 创建新链表节点
37 Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
38     LinkedHashMap.Entry<K,V> p =
39         new LinkedHashMap.Entry<>(hash, key, value, e);
40     linkNodeLast(p);
41     return p;
42 }
43 
44 // 替换链表节点
45 Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
46     LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
47     LinkedHashMap.Entry<K,V> t =
48         new LinkedHashMap.Entry<>(q.hash, q.key, q.value, next);
49     transferLinks(q, t);
50     return t;
51 }
52 
53 // 创建新红黑树节点
54 TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
55     TreeNode<K,V> p = new TreeNode<>(hash, key, value, next);
56     linkNodeLast(p);
57     return p;
58 }
59 
60 // 替换红黑树节点
61 TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
62     LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
63     TreeNode<K,V> t = new TreeNode<>(q.hash, q.key, q.value, next);
64     transferLinks(q, t);
65     return t;
66 }

六、顺序操作

 1 // 把节点从链表解除链接
 2 void afterNodeRemoval(Node<K,V> e) {
 3     // p：即是节点e
 4     // b：e的前一个节点
 5     // a：e的后一个节点
 6     LinkedHashMap.Entry<K,V> p =
 7         (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
 8 
 9     // 置空节点p的前后引用
10     p.before = p.after = null;
11     
12     if (b == null) {
13         // 可知节点e是链表头结点，则e的下一个节点a作为链表的头结点
14         head = a;
15     } else {
16         // 可知节点e本是中间结点，把e下一个节点a作为e上一个节点的后续节点
17         b.after = a;
18     }
19 
20     if (a == null) {
21         // 可知节点e本是链表尾节点，则e的上一个节点b作为链表的尾节点
22         tail = b;
23     } else {
24         // 可知节点e本身是中间节点，把e上一个节点b作为e下一个节点的前置节点
25         a.before = b;
26     }
27 }
28 
29 // 父类HashMap调用putVal()中会调用此方法，移除最少使用的节点
30 void afterNodeInsertion(boolean evict) {
31     // first是最少使用的节点
32     LinkedHashMap.Entry<K,V> first;
33     if (evict && (first = head) != null && removeEldestEntry(first)) {
34         // 获取first的key
35         K key = first.key;
36         // 通过key找到对应Node并移除
37         removeNode(hash(key), key, null, false, true);
38     }
39 }
40 
41 // 把节点移动到链表尾
42 void afterNodeAccess(Node<K,V> e) {
43     LinkedHashMap.Entry<K,V> last;
44     // 仅当accessOrder为true且被访问元素不是尾节点
45     if (accessOrder && (last = tail) != e) {
46         // p：即是节点e
47         // b：e的前一个节点
48         // a：e的后一个节点
49         LinkedHashMap.Entry<K,V> p =
50             (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
51 
52         // 置空节点p的后引用
53         p.after = null;
54 
55         if (b == null) {
56             // 可知节点e本是头结点，则e的下一个节点a作为链表的头结点
57             head = a;
58         } else {
59             // 可知节点e本是中间结点，把e下一个节点a作为e上一个节点的后续节点
60             b.after = a;
61         }
62 
63         if (a != null) {
64             // 可知节点e本身是中间节点，把e上一个节点b作为e下一个节点的前置节点
65             a.before = b;
66         } else {
67             // 可知节点e本是尾节点，则e的上一个节点b作为链表的尾节点
68             last = b;
69         }
70         
71         // p之前没有节点，表明p就是头结点
72         if (last == null) {
73             head = p;
74         } else {
75             // p作为新的尾节点，链接到上一个尾节点之后
76             p.before = last;
77             last.after = p;
78         }
79 
80         tail = p; // tail引用指向p
81         ++modCount; // 修改次数递增
82     }
83 }

七、获取

 1 // 检查LinkedHashMap是否包含指定value
 2 public boolean containsValue(Object value) {
 3     // 从链表头结点开始遍历，逐个查找Entry.value是否等于value
 4     for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {
 5         V v = e.value;
 6         if (v == value || (value != null && value.equals(v)))
 7             return true; // 包含对应value，返回true
 8     }
 9     return false; // 不包含对应value，返回false
10 }
11 
12 // 通过Key获取对应Entry的value
13 public V get(Object key) {
14     Node<K,V> e;
15     if ((e = getNode(hash(key), key)) == null) {
16         // 通过key获取Node为空，返回null作为结果
17         return null;
18     }
19 
20     if (accessOrder) {
21         // 通过key获取Node不为空，执行afterNodeAccess(e)调整顺序
22         afterNodeAccess(e);
23     }
24 
25     return e.value; // 最后把获取的Entry.value返回
26 }
27 
28 // 通过Key获取对应Entry的value
29 public V getOrDefault(Object key, V defaultValue) {
30    Node<K,V> e;
31     if ((e = getNode(hash(key), key)) == null) {
32        // 通过key获取Node为空，返回defaultValue作为结果
33        return defaultValue;
34     }
35     
36     if (accessOrder) {
37         // 通过key获取Node不为空，执行afterNodeAccess(e)调整顺序
38         afterNodeAccess(e);
39     }
40 
41    return e.value; // 最后把获取的Entry.value返回
42 }

八、移除

 1 // 清除所有引用
 2 public void clear() {
 3     super.clear(); // 把HashMap所有Entry都清空
 4     head = tail = null;  // 置空head和tail引用
 5 }
 6 
 7 // 方法主要用于被子类重写，决定最少使用的节点能否被移除
 8 protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
 9     return false;
10 } 

---