Java 容器 LinkedHashMap源码分析2

一、类签名

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

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

二、节点

Entry<K,V>是HashMap.Node<K,V>的子类，增加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) {
         // 调用HashMap构造方法
         super(hash, key, value, next);
     }
 }

三、数据成员

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

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会被移到链尾

四、构造方法

 public LinkedHashMap(int initialCapacity, float loadFactor) {
     super(initialCapacity, loadFactor);
     accessOrder = false;
 }

 public LinkedHashMap(int initialCapacity) {
     super(initialCapacity);
     accessOrder = false;
 }

 public LinkedHashMap() {
     super();
     accessOrder = false;
 }

 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;
 }

五、成员方法

 // 把节点插入到链表尾部
 private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
     LinkedHashMap.Entry<K,V> last = tail;
     tail = p;
     // 如果尾节点为空表明链表没有元素，则p就是头结点
     if (last == null)
         head = p;
     else {
         // 处理双向链表节点
         p.before = last;
         last.after = p;
     }
 }

 // apply src's links to dst
 private void transferLinks(LinkedHashMap.Entry<K,V> src,
                            LinkedHashMap.Entry<K,V> dst) {
     LinkedHashMap.Entry<K,V> b = dst.before = src.before;
     LinkedHashMap.Entry<K,V> a = dst.after = src.after;
     if (b == null)
         head = dst;
     else
         b.after = dst;
     if (a == null)
         tail = dst;
     else
         a.before = dst;
 }

 // 重写HashMap钩子方法
 void reinitialize() {
     super.reinitialize();
     head = tail = null;
 }

 // 创建新链表节点
 Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
     LinkedHashMap.Entry<K,V> p =
         new LinkedHashMap.Entry<>(hash, key, value, e);
     linkNodeLast(p);
     return p;
 }

 // 替换链表节点
 Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
     LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
     LinkedHashMap.Entry<K,V> t =
         new LinkedHashMap.Entry<>(q.hash, q.key, q.value, next);
     transferLinks(q, t);
     return t;
 }

 // 创建新红黑树节点
 TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
     TreeNode<K,V> p = new TreeNode<>(hash, key, value, next);
     linkNodeLast(p);
     return p;
 }

 // 替换红黑树节点
 TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
     LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
     TreeNode<K,V> t = new TreeNode<>(q.hash, q.key, q.value, next);
     transferLinks(q, t);
     return t;
 }

六、顺序操作

 // 把节点从链表解除链接
 void afterNodeRemoval(Node<K,V> e) {
     // p：即是节点e
     // b：e的前一个节点
     // a：e的后一个节点
     LinkedHashMap.Entry<K,V> p =
         (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;

     // 置空节点p的前后引用
     p.before = p.after = null;

     if (b == null) {
         // 可知节点e是链表头结点，则e的下一个节点a作为链表的头结点
         head = a;
     } else {
         // 可知节点e本是中间结点，把e下一个节点a作为e上一个节点的后续节点
         b.after = a;
     }

     if (a == null) {
         // 可知节点e本是链表尾节点，则e的上一个节点b作为链表的尾节点
         tail = b;
     } else {
         // 可知节点e本身是中间节点，把e上一个节点b作为e下一个节点的前置节点
         a.before = b;
     }
 }

 // 父类HashMap调用putVal()中会调用此方法，移除最少使用的节点
 void afterNodeInsertion(boolean evict) {
     // first是最少使用的节点
     LinkedHashMap.Entry<K,V> first;
     if (evict && (first = head) != null && removeEldestEntry(first)) {
         // 获取first的key
         K key = first.key;
         // 通过key找到对应Node并移除
         removeNode(hash(key), key, null, false, true);
     }
 }

 // 把节点移动到链表尾
 void afterNodeAccess(Node<K,V> e) {
     LinkedHashMap.Entry<K,V> last;
     // 仅当accessOrder为true且被访问元素不是尾节点
     if (accessOrder && (last = tail) != e) {
         // p：即是节点e
         // b：e的前一个节点
         // a：e的后一个节点
         LinkedHashMap.Entry<K,V> p =
             (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;

         // 置空节点p的后引用
         p.after = null;

         if (b == null) {
             // 可知节点e本是头结点，则e的下一个节点a作为链表的头结点
             head = a;
         } else {
             // 可知节点e本是中间结点，把e下一个节点a作为e上一个节点的后续节点
             b.after = a;
         }

         if (a != null) {
             // 可知节点e本身是中间节点，把e上一个节点b作为e下一个节点的前置节点
             a.before = b;
         } else {
             // 可知节点e本是尾节点，则e的上一个节点b作为链表的尾节点
             last = b;
         }

         // p之前没有节点，表明p就是头结点
         if (last == null) {
             head = p;
         } else {
             // p作为新的尾节点，链接到上一个尾节点之后
             p.before = last;
             last.after = p;
         }

         tail = p; // tail引用指向p
         ++modCount; // 修改次数递增
     }
 }

七、获取

 // 检查LinkedHashMap是否包含指定value
 public boolean containsValue(Object value) {
     // 从链表头结点开始遍历，逐个查找Entry.value是否等于value
     for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {
         V v = e.value;
         if (v == value || (value != null && value.equals(v)))
             return true; // 包含对应value，返回true
     }
     return false; // 不包含对应value，返回false
 }

 // 通过Key获取对应Entry的value
 public V get(Object key) {
     Node<K,V> e;
     if ((e = getNode(hash(key), key)) == null) {
         // 通过key获取Node为空，返回null作为结果
         return null;
     }

     if (accessOrder) {
         // 通过key获取Node不为空，执行afterNodeAccess(e)调整顺序
         afterNodeAccess(e);
     }

     return e.value; // 最后把获取的Entry.value返回
 }

 // 通过Key获取对应Entry的value
 public V getOrDefault(Object key, V defaultValue) {
    Node<K,V> e;
     if ((e = getNode(hash(key), key)) == null) {
        // 通过key获取Node为空，返回defaultValue作为结果
        return defaultValue;
     }

     if (accessOrder) {
         // 通过key获取Node不为空，执行afterNodeAccess(e)调整顺序
         afterNodeAccess(e);
     }

    return e.value; // 最后把获取的Entry.value返回
 }

八、移除

 // 清除所有引用
 public void clear() {
     super.clear(); // 把HashMap所有Entry都清空
     head = tail = null;  // 置空head和tail引用
 }

 // 方法主要用于被子类重写，决定最少使用的节点能否被移除
 protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
     return false;
 } 

---