LinkedHashMap源码浅析

本文基于JDK8进行解析。

//LinkedHashMap继承了HashMap
public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>
{
   //Entry 继承了HashMap.Node(包含4个域：hash+key+value+next),增加了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);
        }
    }
    private static final long serialVersionUID = 3801124242820219131L;

    /**
     * 双链表的头部
     */
    transient LinkedHashMap.Entry<K,V> head;

    /**
     * 双链表的尾部.
     */
    transient LinkedHashMap.Entry<K,V> tail;

    /**
     *迭代策略：true--->表示按照访问顺序迭代   false--->表示按插入顺序迭代
     * @serial
     */
    final boolean accessOrder;

可以看到，LinkedHashMap在HashMap的基础上添加了一个前指针和后指针，而且支持根据访问顺序进行迭代。

linkNodeLast()

  // 在链表尾部插入结点
    private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
        LinkedHashMap.Entry<K,V> last = tail;
        tail = p; //先更新末尾引用tail,即将tail往后移动
        if (last == null)//如果链表为null，则头结点指向p
            head = p;
        else {//如果链表不为null，则将p插到链表末尾，即改变指针
            p.before = last;
            last.after = p;
        }
    }

transferLinks()插入

 // 使用dst替换src在双向链表中的位置
    //transferLinks的解释，看下文图文解释
    private void transferLinks(LinkedHashMap.Entry<K,V> src,
                               LinkedHashMap.Entry<K,V> dst) {
        LinkedHashMap.Entry<K,V> b = dst.before = src.before;
        LinkedHashMap.Entry<K,V> a = dst.after = src.after;
        if (b == null)
            head = dst;
        else
            b.after = dst;
        if (a == null)
            tail = dst;
        else
            a.before = dst;
    }
 
  //重写了父类newNode方法.扩展双向链表的连接操作.返回了HashMap.Node的子类节点LinkedHashMap.Entry.
    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;
    }

关于transferLinks的图解如下(一般情况)：

replacementNode()

 Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
        LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
        LinkedHashMap.Entry<K,V> t =
            new LinkedHashMap.Entry<K,V>(q.hash, q.key, q.value, next);
        transferLinks(q, t);
        return t;
    }

扩展双向链表替换节点的操作.这个方法用于父类HashMap将HashMap.TreeNode替换为HashMap.Node时调用,这里进行了重写,使用带有双向链表的LinkedHashMap.Entry作为返回值
注意: 这里HashMap.TreeNode是实现了LinkedHashMap.Entry的.也就是参数p,他可以直接强转为实现类LinkedHashMap.Entry

newTreeNode()

 //新建树结点并插入链表尾部
    TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
        TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
        linkNodeLast(p);
        return p;
    }

afterNodeInsertion()

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

afterNodeInsertion 的原理是：元素插入后，可能会删除最旧的、访问次数最少的元素，也就是头节点

afterNodeAccess()

该方法用来实现 按照访问顺序进行迭代

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

afterNodeAccess 的原理是：访问的元素如果不是尾节点，那么就把它与尾节点交换，所以随着元素的访问，访问次数越多的元素越靠后 。

实现一个 LRU 缓存

借助 LinkedHashMap 可以很方便的实现一个 LRU 缓存数据结构，只需设置 accessOrder 为 true，并覆盖 removeEldestEntry 方法即可，代码如下：

final int MAX_CACHE_SIZE = 100;
LinkedHashMap<Object, Object> lru = new LinkedHashMap<Object, Object>(MAX_CACHE_SIZE, 0.75f, true) {
    private static final long serialVersionUID = 1L;
    protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
      return size() > MAX_CACHE_SIZE;
    }
};