Java集合类源码分析（七）：Map接口之LinkedHashMap实现类

系列文章目录

Java集合类源码分析（一）：Java集合类总览
Java集合类源码分析（二）：List接口之ArrayList实现类
Java集合类源码分析（三）：List接口之ArrayList实现类
Java集合类源码分析（四）：List接口之Vector实现类
Java集合类源码分析（五）：Map接口之HashMap实现类
Java集合类源码分析（六）：Map接口之HashTable实现类
Java集合类源码分析（七）：Map接口之LinkedHashMap实现类
Java集合类源码分析（八）：Map接口之TreeMap实现类

一、概念要点

源码第一行注释：

Hash table and linked list implementation of the Map interface, with predictable iteration order. This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order). Note that insertion order is not affected if a key is re-inserted into the map. (A key k is reinserted into a map m if m.put(k, v) is invoked when m.containsKey(k) would return true immediately prior to the invocation.)

由注释可知，LinkedHashMap是通过哈希表和链表实现的，是通过维护一个链表来保证对哈希表迭代时的有序性，而这个有序是指键值对插入的顺序。当向哈希表中重复插入某个键的时候，不会影响到原来的有序性。
LinkedHashMap的实现主要有两部分，一是哈希表，另外一部分是链表。哈希表部分继承了HashMap，而主要需要关系LinkedHashMap链表部分的实现，LinkedHashMap的大致实现如下：

二、LinkedHashMap继承结构图

三、关键源码分析

1. 基本属性

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

LinkedHashMap继承自 HashMap，它从 HashMap 继承了与哈希表相关的操作，在 LinkedHashMap 中其是专注于链表的实现，与与链表实现相关的属性有：

/**
 * LinedHashMap的链表节点继承了HashMap的node节点
 */
static class Entry<K,V> extends HashMap.Node<K,V> {
	// 节点的前指针和后指针，可以看出LinkedHashMap是一个双向链表
    Entry<K,V> before, after;
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}
/**
 * The head (eldest) of the doubly linked list.（头指针）
 * header中不保存key-value对，只保存前后节点的引用
 */
transient LinkedHashMap.Entry<K,V> head;
/**
 * The tail (youngest) of the doubly linked list.（尾指针）
 */
transient LinkedHashMap.Entry<K,V> tail;
/**
 * 默认为false。
 * true for access-order(访问顺序), false for insertion-order（插入顺序）.
 */
final boolean accessOrder;

2. LinkedHashMap类内工具方法

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);
    // 将p链接至原LinkedHashMap的最后
    linkNodeLast(p);
    return p;
}

/**
 *  HashMap源码中有三个空方法，在LinkedHashMap中有自己的实现
 */
// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }

/**
 * 将最近访问的节点放到链表的最后
 */
void afterNodeAccess(Node<K,V> e) { // move node to last
	// 链表的最后一个节点
    LinkedHashMap.Entry<K,V> last;
    // 需要accessOrder为true，即按访问顺序为主，且e不是尾节点
    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的removeNode方法。想一想，通过
 * afterNodeInsertion方法和afterNodeAccess方法，就可以实现简单一个基于最近最少使用（LRU）的淘汰策略，
 * 当然，我们还要重写removeEldestEntry方法，因为它默认返回的是false
 */
void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry<K,V> first;
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        K key = first.key;
        removeNode(hash(key), key, null, false, true);
    }
}

/**
 * 当HashMap删除一个键值对时调用，它会把在HashMap中删除的那个键值对一并从链表中删除，保证了哈希表和链表的一致性。
 */
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的源码中put方法，说明它并没有重写put方法，所以在调用的LinkedHashMap put方法其实是HashMap的put方法。
 * 因为HashMap的put方法中调用了afterNodeAccess方法和afterNodeInsertion方法，已经足够保证链表的有序性了，所以它也就没有重写put方法了。
 * remove方法也是如此。
 */

3. 构造函数

通过HashMap的构造函数的实现，并设置accessOrder=false。

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);
}
/**
 * 此构造方法可以修改LinkedHashMap默认的排序方式accessOrder
 */
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

4.LinkedHashMap操作方法

/**
 * 判断LinkedHashMap中是否包含特定值
 */
public boolean containsValue(Object 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;
    }
    return false;
}

/**
 * 获取指定key的value值，并在accessOrder为true时，将最近访问的节点放在链表的最后
 * 通过调用HashMap的getNode()方法来判断是否包含key
 */ 
public V get(Object key) {
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) == null)
    // 此处返回null，不代表没有对应的key值，可能此key就为null
    // HashMap中是允许key为null的
        return null;
    if (accessOrder)
        afterNodeAccess(e);
    return e.value;
}

四、LinkedHashMap关注要点

1. LinkedHashMap是非线程安全的。
2. LinkedHashMap中加入了一个head头结点，将所有插入到该LinkedHashMap中的Entry按照插入的先后顺序依次加入到以head为头结点的双向循环链表的尾部
3. LinkedHashMap是HashMap和LinkedList两个集合类存储结构的结合，所有put进来的Entry都保存在一个哈希表中，但它又额外定义了一个以head为头结点的空的双向循环链表，每次put进来Entry，除了将其保存到对哈希表中对应的位置上外，还要将其插入到双向循环链表的尾部。
4. LinkedHashMap继承自HashMap，同样允许key和value为null。
5. accessOrder标志属性，当为false时，表示双向链表中的元素按照Entry插入LinkedHashMap到中的先后顺序排序，当它为true时，表示双向链表中的元素按照访问的先后顺序排列。
6. LinkedHashMap如何实现LRU。首先，当accessOrder为true时，才会开启按访问顺序排序的模式，才能用来实现LRU算法。我们可以看到，无论是put方法还是get方法，都会导致目标Entry成为最近访问的Entry，因此便把该Entry加入到了双向链表的末尾，这样便把最近使用了的Entry放入到了双向链表的后面，多次操作后，双向链表前面的Entry便是最近没有使用的，这样当节点个数满的时候，删除的最前面的Entry(head后面的那个Entry)便是最近最少使用的Entry。