JDK源码阅读（三）、LinkedHashMap

一、LinkedHashMap原理

        LinkedHashMap继承自HashMap，所以，它有hashMap的全部特性，它内部采用存储数据额的节点继承自HashMap的node。有一个before与after用于维护插入或者访问的顺序。它内部的put，get，remove等方法都是调用HashMap的方法。当这些方法调用完成后再通过一个回调子类的方法进行子类的相关操作。（因为它一些特性与HashMap重合，相关内容请查看点击打开链接）

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分析

    （1）关键的属性

    //表示LinkedHashMap的头节点
    transient LinkedHashMap.Entry<K,V> head;
    //表示尾节点
    transient LinkedHashMap.Entry<K,V> tail;
    //表示访问顺序，false表示插入顺序，true为访问顺序,访问过的会放在后面
    final boolean accessOrder;

     （2）关键的方法

         新创建节点，类似的还有newTreeNode

    /**
     * 该方法只有在新创建节点的时候才会被调用
     * 创建新的节点，将节点插入到hashMap中。
     * @param hash
     * @param key
     * @param value
     * @param e
     * @return
     */
    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;
        }
    }

  afterNodeRemove、afterNodeAccess、afterNodeInsertion方法，这三个方法是在HashMap中有一个空的实现，而LinkedHashMap对其进行了自己的实现。所以在调用完HashMap相关方法后，在出现这三个方法的地方调用子类的实现.

     /*
     * 添加元素调用的是HashMap的默认行为
     *    但插入元素后会调用afterNodeAccess，
     *    LinkedHashMap对其进行了实现，相关内容如下。
     *    accessOrder为true才会执行
     *    这个函数的作用是将e从链表中拿出来放在末尾
     *    之前的位置由其前后节点连接起来
     * @param e
     */

    void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        //如果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;
            //表明e是头结点，这时候头结点应该为e的after
            if (b == null)
                head = a;
            //如果e的before不为空的话，将其与e.after连接起来
            else
                b.after = a;
            //再让e.after与e.before建立关系
            if (a != null)
                a.before = b;
            //e没有后继节点，表明e是最后一个节点
            else
                last = b;
            //将e节点放在末尾
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }
     /**
     * 当插入一个新元素的时候，会删除头结点。
     * 这个方法默认不会生效，因为removeEldestEntry永远返回false
     * 如果使用必须重写removeEldestEntry
     * @param 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);
        }
    }

    /**
     * 在节点删除之后调用它，节点删除使用父类HashMap的方法。
     * 将之前的节点与当前节点之后的节点建立联系
     * @param e
     */
    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;
    }

另外还有一些遍历的方法，这些其实就是链表的遍历。也没什么好说的了。

ps:如有不对，请大佬指出~