LinkedHashMap 源码解析

一、简介

LinkedHashMap 继承了 HashMap 类，是 HashMap 的子类，LinkedHashMap 的大多数方法的实现直接使用了父类 HashMap 的方法。LinkedHashMap 可以说是 HashMap 和 LinkedList 的结合体，既使用了 HashMap 的数据结构，又借用了 LinkedList 双向链表的结构。

LinkedHashMap 实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双向链表。此链表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。

注意，此实现不是同步的。如果多个线程同时访问链接的哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。

二、继承结构

LinkedHashMap 继承了 HashMap 类，有着和 HashMap 类似的操作。

三、属性

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

    private static final long serialVersionUID = 3801124242820219131L;

    transient LinkedHashMap.Entry<K,V> head;

    transient LinkedHashMap.Entry<K,V> tail;

    final boolean accessOrder;
}

在 HashMap 的基础上，LinkedHashMap 新增了 head 和 tail 属性，表示指向链表的头节点和尾节点。accessOrder 表示按访问顺序遍历还是按插入顺序遍历，如果 accessOrder 为 true，表示按访问顺序遍历，如果为 false，表示按插入顺序遍历。

四、构造方法

LinkedHashMap 有 5 种构造方法，大部分都在内部调用父类 HashMap 的构造方法。

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

无参构造方法表示用默认的初始化容量和负载因子创建一个 LinkedHashMap，以插入顺序取得键值对。

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

一个参数的构造方法表示构造一个指定初始容量的 LinkedHashMap，以插入顺序取得键值对。

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

两个参数的构造方法表示构造一个指定初始容量和负载因子的 LinkedHashMap，以插入顺序取得键值对。

public LinkedHashMap(int initialCapacity,
                     float loadFactor,
                     boolean accessOrder) {
    super(initialCapacity, loadFactor);
    this.accessOrder = accessOrder;
}

三个参数的构造方法表示根据指定容量、装载因子和键值对保持顺序创建一个 LinkedHashMap。

public LinkedHashMap(Map<? extends K, ? extends V> m) {
    super();
    accessOrder = false;
    putMapEntries(m, false);
}

该构造方法通过传入的 map 创建一个 LinkedHashMap，容量为默认容量和 map.size() / DEFAULT_LOAD_FACTORY + 1 的较大者，装载因子为默认值。

五、常用方法

0x01、put(K key, V value)

LinkedHashMap 的 put() 方法沿用了父类 HashMap 的 put() 方法，但我们也提到了像 LinkedHashMap 的 Entry 类就是继承了 HashMap 的 Node 类，同样的，HashMap 的 put() 方法中调用的其他方法在 LinkedHashMap 中已经被重写。

1. newNode(int hash, K key, V value, Node e)

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

LinkedHashMap 重写了 newNode() 方法，通过此方法保证了插入的顺序性。

2. afterNodeAccess(Node e)

void afterNodeAccess(Node<K,V> e) { // move node to last
    // 在执行方法前的上一次的尾节点
    LinkedHashMap.Entry<K,V> last;
    // 当 accessOrder 为 true 并且传入的节点并不是上一次的节结点时
    if (accessOrder && (last = tail) != e) {
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        // 将 p.after 设置为 null，断开了与后一个节点的关系，但还未确定其位置
        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;
        }
        // 将节点 p 设置为尾节点
        tail = p;
        ++modCount;
    }
}

关于 afterNodeAccess() 方法，在 HashMap 中没给具体实现，而在 LinkedHashMap 重写了，目的是保证操作过的 Node 节点永远在最后，从而保证读取的顺序性，在调用 put() 方法和 get() 方法时都会用到。

3. afterNodeInsertion(boolean 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;
}

我们看到在 LinkedHashMap 中还重写了 afterNodeInsertion(boolean evict) 方法，它的目的是移除链表中最老的节点对象，也就是当前在头部的节点对象，但实际上在 JDK 8 中不会执行，因为 removeEldestEntry() 方法始终返回 false。

0x02、get(Object key)

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

LinkedHashMap 的 get() 方法与 HashMap 中 get() 方法的不同点在于多了 afterNodeAccess() 方法，afterNodeAccess() 方法在上文已经讲过。

0x03、remove(Object key)

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

remove() 方法也直接使用了 HashMap 中的 remove()，在 HashMap 章节中并没有讲解，因为 remove() 的原理很简单，通过传递的参数 key 计算出 hash，据此可找到对应的 Node 节点，如果该 Node 节点是直接在数组中的 Node，则将 table 数组该位置的元素设置为 node.next，如果是链表中的，则遍历链表，直到找到对应的 Node 节点，然后将该节点的上一个节点的 next 设置为该节点的 next。

void afterNodeRemoval(Node<K,V> e) { // unlink
    LinkedHashMap.Entry<K,V> p =
        (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
    // 将待删除节点的 before 和 after 都设置为 null
    p.before = p.after = null;
    // 如果节点 b 为 null
    if (b == null)
        // 表示待删除节点 p 为头部节点，该节点拿掉后，该节点的下一个节点 a 就为头部节点 head
        head = a;
    else
        // 否则设置待删除节点的上一个节点 b 的 after 属性为节点 a
        b.after = a;
    // 如果节点 a 为 null
    if (a == null)
        // 表示待删除节点 p 为尾部节点，该节点拿掉后，该节点的上一个节点 a 就为尾部节点 tail
        tail = b;
    else
        // 否则设置待删除节点的下一个节点 a 的 before 属性为节点 b
        a.before = b;
}

LinkedHashMap 重写了其中的 afterNodeRemoval(Node e)，该方法在 HashMap 中没有具体实现，通过此方法在删除节点的时候调整了双链表的结构。

六、总结

1. LinkedHashMap 继承于 HashMap，是基于 HashMap 和双向链表来实现的。

2. HashMap 无序，LinkedHashMap 有序，可分为插入顺序和访问顺序两种。如果是访问顺序，那 put() 和 get() 操作已存在的 Entry 时，都会把 Entry 移动到双向链表的表尾（其实是先删除再插入）。

3. LinkedHashMap 存取数据，还是跟 HashMap 一样使用的 Entry[] 的方式，双向链表只是为了保证顺序。

4. LinkedHashMap 是线程不安全的。

参考

https://www.cnblogs.com/LiaHon/p/11180869.html
https://www.jianshu.com/p/8f4f58b4b8ab