Java 集合框架（八）：LinkedHashMap

LinkedHashMap

LinkedHashMap 是一个链表，哈希表，线程不安全的，允许 key 和 value 为 null。

它继承自 HashMap ，实现了 Map<K,V> 接口，内部维护了一个双向链表。每次插入数据或者访问，修改数据时，会增加节点或者调整链表的节点顺序，以决定迭代输出的顺序。

默认情况，遍历顺序时按照插入节点的顺序。也可以在构造时传入 accessOrder 参数，使得其遍历顺序按照访问的顺序输出（访问后节点会被移至链表尾部）。

LinkedHashMap 继承自 HashMap，所以继承了 HashMap 的特点，比如扩容策略，哈希桶的长度是 2 的 N 次方等等。

节点

LinkedHashMap 的节点 Entry<K,V> 继承自 HashMap.Node<K,V>，在其基础上扩展可以下，改成了一个双向链表。

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

同时类里有两个成员变量 head tail，分别指向内部双链表的头和尾。

//双向链表的头结点
transient LinkedHashMap.Entry<K,V> head;

//双向链表的尾节点
transient LinkedHashMap.Entry<K,V> tail;

构造函数

//默认是false，则迭代时输出的顺序是插入节点的顺序。若为true，则输出的顺序是按照访问节点的顺序
//为true时，可以在这基础之上构建一个LruCach
final boolean accessOrder;

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

构造函数和 HashMap 相比，就是增加了一个 accessOrder 参数，用于控制迭代时的节点顺序。

put 方法

LinkedHashMap 并没有重写任何 put 方法，但是重写了构建新节点的 newNode() 方法。newNode() 在每次构建新节点时，通过 linkNodeLast(p)，将新节点链接在内部双向链表的尾部。

//在构建新节点时，构建的是`LinkedHashMap.Entry` 不再是`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;
}
//将新增的节点，连接在链表的尾部
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;
    }
}

以及 HashMap 专门预留给 LinkedHashMap 的 afterNodeAccess() afterNodeInsertion() afterNodeRemoval() 方法。

//回调函数，新节点插入之后回调 ， 根据evict 和   判断是否需要删除最老插入的节点。如果实现LruCache会用到这个方法。
void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry<K,V> first;
    //LinkedHashMap 默认返回false 则不删除节点
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        K key = first.key;
        removeNode(hash(key), key, null, false, true);
    }
}
//LinkedHashMap 默认返回false 则不删除节点。 返回true 代表要删除最早的节点。通常构建一个LruCache会在达到Cache的上限是返回true
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    return false;
}

remove 方法

LinkedHashMap 也没有重写 remove 方法，因为它的删除逻辑和 HashMap 并无区别。但是它重写了 afterNodeRemoval() 这个回调方法。是删除节点操作真正的执行者。

//在删除节点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;
}

get 方法

LinkedHashMap 重写了 get() 和 getOrDefault() 方法：

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;
}
public V getOrDefault(Object key, V defaultValue) {
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) == null)
        return defaultValue;
    if (accessOrder)
        afterNodeAccess(e);
    return e.value;
}

对比 HashMap 中的实现，LinkedHashMap 之是增加了在成员变量 accessOrder 为 true 的情况下，要去回调 void afterNodeAcceess(Node<K,V> e) 函数，afterNodeAcceess 函数中，会将当前被访问的节点 e，移动至内部的双向链表的尾部。

void afterNodeAccess(Node<K,V> e) { // move node to last
    LinkedHashMap.Entry<K,V> last;//原尾节点
    //如果accessOrder 是true ，且原尾节点不等于e
    if (accessOrder && (last = tail) != e) {
        //节点e强转成双向链表节点p
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        //p现在是尾节点， 后置节点一定是null
        p.after = null;
        //如果p的前置节点是null，则p以前是头结点，所以更新现在的头结点是p的后置节点a
        if (b == null)
            head = a;
        else//否则更新p的前直接点b的后置节点为 a
            b.after = a;
        //如果p的后置节点不是null，则更新后置节点a的前置节点为b
        if (a != null)
            a.before = b;
        else//如果原本p的后置节点是null，则p就是尾节点。 此时 更新last的引用为 p的前置节点b
            last = b;
        if (last == null) //原本尾节点是null  则，链表中就一个节点
            head = p;
        else {//否则 更新 当前节点p的前置节点为 原尾节点last， last的后置节点是p
            p.before = last;
            last.after = p;
        }
        //尾节点的引用赋值成p
        tail = p;
        //修改modCount。
        ++modCount;
    }
}

containsValue

LinkedHashMap 重写了该方法，相比于 HashMap 的实现，更为高效。

public boolean containsValue(Object 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;
    }
    return false;
}

相比与 HashMap 用两个 for 循环的实现：

// 两层 for 循环，先遍历数组，然后遍历数组里面的链表
public boolean containsValue(Object value) {
    Node<K,V>[] tab; V v;
    if ((tab = table) != null && size > 0) {
        for (int i = 0; i < tab.length; ++i) {
            for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                if ((v = e.value) == value ||
                    (value != null && value.equals(v)))
                    return true;
            }
        }
    }
    return false;
}

总结

LinkedHashMap 相比于 HashMap 的源码相对简单。它继承了 HashMap，仅重写了几个方法用来改变它的迭代遍历时的顺序。

在每次插入数据，或者访问，修改数据时，会增加节点，或者调整链表的节点顺序。以决定迭代的输出顺序。

LinkedHashMap 的存储与 HashMap 相同。还是数组加链表加红黑树。只不过元素之间会有双向指针，这个指针能决定元素的迭代和访问顺序。

经典用法

LinkedHashMap 除了可以保证迭代顺序外，还有一个非常有用的用法：可以轻松实现一个采用了 FIFO 替换策略的缓存。LinkedHashMap 有一个子类方法 protected boolean removeEldestEntry(Map.Entry<K,V> eldest)，该方法的作用时告诉 Map 要删除 “最老” 的 Entry (最早插入的)。当元素个数超过一定数量时，让 removeEldestEntry() 返回 true，就能够实现一个固定大小的 FIFO 策略的缓存。

/** 一个固定大小的FIFO替换策略的缓存 */
class FIFOCache<K, V> extends LinkedHashMap<K, V>{
    private final int cacheSize;
    public FIFOCache(int cacheSize){
        this.cacheSize = cacheSize;
    }

    // 当Entry个数超过cacheSize时，删除最老的Entry
    @Override
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
       return size() > cacheSize;
    }
}