LinkedHashMap源码解析

1.概述

LinkedHashMap是HashMap的子类，但是内部还有一个双向链表维护键值对的顺序，每个键值对既位于哈希表中，也位于双向链表中。LinkedHashMap支持两种顺序插入顺序 、 访问顺序：

• 访问顺序：根据键值对的添加顺序进行访问，对应的配置是属性accessOrder设置为false。
• 对应的配置是属性accessOrder设置为true，调用get方法过后元素访问顺序发生了变化。

// 第三个参数用于指定accessOrder值
Map<String, String> linkedHashMap = new LinkedHashMap<>(16, 0.75f, true);
linkedHashMap.put("name1", "josan1");
linkedHashMap.put("name2", "josan2");
linkedHashMap.put("name3", "josan3");
System.out.println("开始时顺序：");
Set<Entry<String, String>> set = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext()) {
    Entry entry = iterator.next();
    String key = (String) entry.getKey();
    String value = (String) entry.getValue();
    System.out.println("key:" + key + ",value:" + value);
}
System.out.println("通过get方法，导致key为name1对应的Entry到表尾");
//在get方法获取后，重新遍历 输出结果是name2->name3->name1 也就是LRU算法
linkedHashMap.get("name1");
Set<Entry<String, String>> set2 = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator2 = set2.iterator();
while(iterator2.hasNext()) {
    Entry entry = iterator2.next();
    String key = (String) entry.getKey();
    String value = (String) entry.getValue();
    System.out.println("key:" + key + ",value:" + value);
}

2.类图

3.属性

/**
 * 头节点。
 * 越老的节点，放在越前面。所以头节点，指向链表的开头
 */
transient LinkedHashMap.Entry<K,V> head;

/**
 * 尾节点
 * 越新的节点，放在越后面。所以尾节点，指向链表的结尾
 */
transient LinkedHashMap.Entry<K,V> tail;

/**
 * 是否按照访问的顺序。
 * true ：按照 key-value 的访问顺序进行访问。
 * false ：按照 key-value 的插入顺序进行访问。
 */
final boolean accessOrder;

4.构造方法

LinkedHashMap一共有 5 个构造方法，其中四个和HashMap相同，只是多初始化 accessOrder = false 。所以，默认使用插入顺序进行访问。

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

5.put方法

因为LinkedHashMap是继承于HashMap的，所以put方法是在父类HashMap中实现的，在调用newNode方法时会回调自己的方法。

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)
            //创建节点时会调用自己的newNode方法
            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;
    }

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

/**
 * head与tail节点分别指向第一个节点和最后一个节点，当没有节点时，都为null
 */
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
    LinkedHashMap.Entry<K,V> last = tail;
    tail = p;
    //当尾节点为null时，说明该链为空，将头节点和尾节点都指向新建的节点
    if (last == null)
        head = p;
    //否则 last节点的after节点指向p,p的befor节点指向last
    else {
        p.before = last;
        last.after = p;
    }
}                                                                                        

6.查找元素

//(按照key-value的插入顺序)，即accessOrder=true
public V get(Object key) {
    Node<K,V> e;
    if ((e = getNode(hash(key), key)) == null)
        return null;
    //如果accessOrder设置为true，则访问过的元素会插入到双线链表的末尾
    if (accessOrder)
        afterNodeAccess(e);
    return e.value;
}

下图展示了双向链表访问节点A前后结构的变化：

7.节点回调操作

7.1 afterNodeAccess

//将查到的元素移动到节点末尾
void afterNodeAccess(Node<K,V> e) { // move node to last
    LinkedHashMap.Entry<K,V> last;
    if (accessOrder && (last = tail) != e) {
        //p=B p.before=A p.after=C
        LinkedHashMap.Entry<K,V> p =
            (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
        //将p从链表中移除
        p.after = null;
        //b的下一个节点指向a:A<=>B
        if (b == null)
            head = a;
        else
            b.after = a;
        //处理 a 的前一个节点指向 b
        if (a != null)
            a.before = b;
        else
            last = b;
        //将 p 添加到链表的尾巴
        if (last == null)
            head = p;
        else {
            //将p接在链表的最后
            p.before = last;
            last.after = p;
        }
        tail = p;
        ++modCount;
    }
}

7.2 afterNodeInsertion

// evict 翻译为驱逐，表示是否允许移除元素
void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry<K,V> first;
    // first = head 记录当前头节点。因为移除从头开始，最老
    // <1> removeEldestEntry(first) 判断是否满足移除最老节点
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        // <2> 移除指定节点
        K key = first.key;
        removeNode(hash(key), key, null, false, true);
    }
}

7.3 afterNodeRemoval

void afterNodeRemoval(Node<K,V> e) { // unlink
    // 将 e 赋值给 p 【因为要 Node 类型转换成 Entry 类型】
    // 同时 b、a 分别是 e 的前后节点
    LinkedHashMap.Entry<K,V> p =
        (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
    // 将 p 从链表中移除
    p.before = p.after = null;
    // 处理 b 的下一个节点指向 a
    if (b == null)
        head = a;
    else
        b.after = a;
    // 处理 a 的前一个节点指向 b
    if (a == null)
        tail = b;
    else
        a.before = b;
}

8 .基于LinkedHashMap实现LRU算法

LRU算法：最近最少使用的算法。实现思路是LRUCache限定了可以存储元素的个数，当达到临界点的时候，再次插入元素就会删除头部节点元素，因为此时之前被访问的元素已经移到后面部分（accessOrder=true）。

class LRUCache<K, V> extends LinkedHashMap<K, V> {

    private final int CACHE_SIZE;

    /**
     * 传递进来最多能缓存多少数据
     *
     * @param cacheSize 缓存大小
     */
    public LRUCache(int cacheSize) {
        // true 表示让 LinkedHashMap 按照访问顺序来进行排序，最近访问的放在头部，最老访问的放在尾部。
        super((int) Math.ceil(cacheSize / 0.75) + 1, 0.75f, true);
        CACHE_SIZE = cacheSize;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        // 当 map 中的数据量大于指定的缓存个数的时候，就自动删除最老的数据。
        return size() > CACHE_SIZE;
    }

}

9.小结

• LinkedHashMap 是 HashMap 的子类，增加了顺序访问的特性。

• 【默认】当 accessOrder = false 时，按照 key-value 的插入顺序进行访问。

• 当 accessOrder = true 时，按照 key-value 的读取顺序进行访问。

• LinkedHashMap 的顺序特性，通过内部的双向链表实现，所以我们把它看成是 LinkedList +HashMap 的组合。

• LinkedHashMap 通过重写 HashMap 提供的回调方法，从而实现其对顺序的特性的处理。同时，因为 LinkedHashMap 的顺序特性，需要重写 #keysToArray(T[] a) 等遍历相关的方法。

• LinkedHashMap 可以方便实现 LRU 算法的缓存