Java 集合 3：LinkedHashMap工作原理及实现

LinkedHashMap 概述

由于 HashMap 中的 entry 是无序的，也就是说，当 map.entrySet() 得到的 entry的集合既不能按照插入顺序排列，也不能按照访问先后顺序排序。

那么 LinkedHashMap 就可以解决这个问题。LinkedHashMap 可以让元素：

按照插入顺序排列
也可以按照访问的先后顺序排序

这里需要注意，不能按照 key 的大小排序，那是 TreeMap 的功能，不要弄混淆了。

如下 Demo：

public class Test {
    public static void main(String args[]){
        Map<String,String> map = new LinkedHashMap<>(16,0.75f,true);

        map.put("A","a");
        map.put("B","b");
        map.put("C","c");
        map.put("D","d");
        map.put("E","e");

        for(Map.Entry<String,String> entry : map.entrySet()) {
            System.out.println(entry);
        }

        map.get("D");
        map.get("B");
        System.out.println("==========");

        for(Map.Entry<String,String> entry : map.entrySet()) {
            System.out.println(entry);
        }
    }
}

那么输出：

A=a
B=b
C=c
D=d
E=e
==========
A=a
C=c
E=e
D=d
B=b

这里可以看到，在 map.get(“D”); 和 map.get(“B”); 之后，打印的最后就变了，这个是按照访问来排序。

原理

LinkedHashMap 继承于 HashMap，很多方法都是直接用了 HashMap 的方法，那么本身再在 HashMap 的基础上提供一个排序的功能。

它的成员变量有：

transient LinkedHashMap.Entry<K,V> head;
transient LinkedHashMap.Entry<K,V> tail;
final boolean accessOrder;

这个时候其实可以猜到，其实是用了一个链表来维护顺序。这个 accssOrder 表示是否需要按照访问顺序来排序，如果不需要，那么默认就是按照插入顺序来排序。如上代码的构造方法 LinkedHashMap<>(16,0.75f,true); 的 true 就表示了需要按照访问顺序。

put(K key, V value)

在进行 put(K key, V value) 操作的时候， LinkedHashMap 实际上是调用了 HashMap 的 put(K key, V value) 方法，然后在 HashMap 中的 put(K key, V value) 方法后，有一句：

afterNodeAccess(e);

这个方法就是留给 LinkedHashMap 来实现。除此之外，还有

// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }

并且注释已经写明了是给 LinkedHashMap 来用的。

到这里，我们就可以知道原理：LinkedHashMap 进行 put(K key, V value) 操作的时候，调用了 HashMap 的 put(K key, V value)， 然后 HashMap 再调用回 LinkedHashMap 特定的方法，来实现排序，get(),remove() 方法同理。而 LinkedHashMap 实现排序的方式就是通过链表。

Java LinkedHashMap工作原理及实现 ，用的其实是一个双向链表。

再具体一下 afterNodeAccess(e);，以下这个是 HashMap 的 put 方法：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    ......
    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;
        }
    }
    ......
}

可以看到，在 else 的 for 循环中，put 了这个 key-value 之后，会在下面 if (e != null) 调用 afterNodeAccess(e);：

这里要注意一点，这里的 节点类型是：

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

可以看到，保存了 before, after; 其实这个就是用来引用前后节点的，这样可以用来做双端队列。

void afterNodeAccess(Node<K,V> e) { // move node to last
    LinkedHashMap.Entry<K,V> last;
    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;
    }
}

这个代码就可以具体看到，首先，判断你是不是要按照访问顺序来使用，如果不是的话，那这里什么也不做。