LinkedHashMap 笔记整理

有关 LinkedHashMap，需要有 HashMap 的基础：HashMap 笔记整理

源码基于 Java 8

主要参考文章：
1、面试必备：LinkedHashMap源码解析（JDK8）
2、https://lrh1993.gitbooks.io/android_interview_guide/content/java/basis/LinkedHashMap.html

---

1、概述

截图自：面试必备：LinkedHashMap源码解析（JDK8）

再附上一张 LinkedHashMap 的结构图：

引用自：图解LinkedHashMap原理

---

2、成员及构造方法

// 指向头部节点
transient LinkedHashMap.Entry<K,V> head;
// 指向尾部节点
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.
 * 用于迭代访问时的顺序，true 表示按照访问的顺序来；false 为默认的，按照节点的插入顺序
 * @serial
 */
final boolean accessOrder;

// 节点对应的数据结构，
// 在 HashMap.Node 的基础上，新增了 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) {
        super(hash, key, value, next);
    }
}

对于其构造方法，就不另外放出来了，因为基本上都是直接继承自其父类（HashMap）的，然后把 accessOrder 默认置为 false。

3、成员方法

3.1 增

LinkedHashMap 没有重新再实现 put() 方法，而是基于 HashMap#put()，且实现了 HashMap 中定义的三个方法，如下：

// 节点被访问之后调用
void afterNodeAccess(Node<K,V> p) { }
// 节点被插入之后调用
void afterNodeInsertion(boolean evict) { }
// 节点被移除之后调用
void afterNodeRemoval(Node<K,V> p) { }

来完整的实现 LinkedHashMap 中的 put 操作。

// HashMap.java
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
               
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
        
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

上面是来自 HashMap#put() 方法的具体实现，有几个点需要注意：

（1）重新实现了 newNode() 方法

// LinkedHashMap.java
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;
    }
}

在 newNode() 方法中，不仅会生成 LinkedHashMap.Entry 节点，还会通过 linkNodeLast() 将该节点添加至双向列表的尾部。这也就对应着的 accessOrder 默认为 false（即默认按照插入顺序）。

（2）会调用 afterNodeAccess(e)

// 将节点 e 置于双向链表的尾部
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
        ++modCount;
    }
}

可以看到，在 afterNodeAccess(e) 方法中，会先判断 accessOrder，以及 e 是不是双向链表的尾部节点。

要判断 e 是不是双向链表的尾部节点 的原因是因为在 newNode() 方法中，已经将该节点添加至双向列表的尾部，不能再重复添加了。

从 afterNodeAccess() 的调用时机可以看到，对于 put 操作，如果目标 key 已经存在，即对应的节点已经存在，则会把这次 put 也看作是访问节点的操作。然后根据 accessOrder 判断是否要将其移到双向链表的末尾。

（3）调用 afterNodeInsertion(evict)

// 根据判断，看是否要移除最老的那个
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);
    }
}

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    return false;
}

afterNodeInsertion() 是用在一定条件下移除最老的节点。当然 LinkedHashMap 中 removeEldestEntry() 返回 false，因此不用 care。

该方法在关于实现 LruCache 的时候会用到。

3.2 删

对于 LinkedHashMap 的 remove() 也于 put() 类似，也是在 HashMap 的基础上完善的。

// HashMap.java
public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                tab[index] = node.next;
            else
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

可以看到，在 HashMap#removeNode() 中会调用 afterNodeRemoval(node)，而该方法在 LinkedHashMap 中实现如下：

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

其会把 node 也从双向链表中移除调。

3.3 查

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#getNode() 的基础上，还会调用 afterNodeAccess() 方法，从而适时的修改对应节点的顺序。

3.4 containsValue()

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

containsValue() 也被重写了，会直接从双向链表的头部开始遍历，因此代码比较精简。

3.5 使用迭代器遍历

public Set<Map.Entry<K,V>> entrySet() {
    Set<Map.Entry<K,V>> es;
    return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es;
}

final class LinkedEntrySet extends AbstractSet<Map.Entry<K,V>> {
    public final int size()                 { return size; }
    public final void clear()               { LinkedHashMap.this.clear(); }
    public final Iterator<Map.Entry<K,V>> iterator() {
        return new LinkedEntryIterator();
    }
    public final boolean contains(Object o) {
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry<?,?> e = (Map.Entry<?,?>) o;
        Object key = e.getKey();
        Node<K,V> candidate = getNode(hash(key), key);
        return candidate != null && candidate.equals(e);
    }
    public final boolean remove(Object o) {
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>) o;
            Object key = e.getKey();
            Object value = e.getValue();
            return removeNode(hash(key), key, value, true, true) != null;
        }
        return false;
    }
    public final Spliterator<Map.Entry<K,V>> spliterator() {
        return Spliterators.spliterator(this, Spliterator.SIZED |
                                        Spliterator.ORDERED |
                                        Spliterator.DISTINCT);
    }
    public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
        if (action == null)
            throw new NullPointerException();
        int mc = modCount;
        for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
            action.accept(e);
        if (modCount != mc)
            throw new ConcurrentModificationException();
    }
}

final class LinkedEntryIterator extends LinkedHashIterator
    implements Iterator<Map.Entry<K,V>> {
    public final Map.Entry<K,V> next() { return nextNode(); }
}

使用迭代器遍历，实际上就是从双向链表的头部开始遍历，而双向链表的节点顺序是在 LinkedHashMap 的增、删、改、查时都会更新维护的，以满足按照插入顺序输出，还是访问顺序输出。

iterator.next() 实际上是调用 LinkedHashIterator#nextNode()；
iterator.remove() 则是 LinkedHashMap#removeNode()。

---

4、总结

需要补充的是，在 afterNodeAccess() 函数中，会修改 modCount, 因此当 accessOrder==true 的模式下,迭代LinkedHashMap 时，如果同时查询访问数据，也会导致 fail-fast，因为迭代的顺序已经改变。

截图自：面试必备：LinkedHashMap源码解析（JDK8）