JDK13-LinkedHashMap源码分析：如何按照访问顺序或插入顺序管理节点

LinkedHashMap继承于HashMap，使用元素的自然顺序对元素进行排序。
Entry类是LinkedHashMap的嵌套类，代表LinkedHashMap当中的节点，继承HashMap.Node类，且调用父类的构造函数构造。

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代表实现的是双向链表

有四个Entry：before、after、head、tail在LinkedHashMap实现保序时起重要作用。
LinkedHashMap还是调用HashMap的putVal函数，
putVal函数的解析可以参考链接：
https://blog.csdn.net/weixin_44893585/article/details/103638927
LinkedHashMap重写了putVal函数调用的一个newNode函数
就是这个函数使得LinkedHashMap能够保序

HashMap.Node<K,V> newNode(int hash, K key, V value, HashMap.Node<K,V> e) {
        LinkedHashMap.Entry<K,V> p =
                new LinkedHashMap.Entry<>(hash, key, value, e);
        linkNodeLast(p);//调用这个函数，使p按照插入的顺序存储
        return p;
    }

并且调用linkNodeLast函数，以保持插入顺序

private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
        LinkedHashMap.Entry<K,V> last = tail;
        tail = p;
        //说明在没有产生过新节点的情况下，tail才等于null，否则tail代表上一个p
        if (last == null)//说明p是放入的第一个元素
            head = p;//p就是头
        else {
            p.before = last;
            last.after = p;//把p放到上一个元素的后面，实现保序
        }
    }

在putVal方法的最后，

            ···//之前的省略
            //至此，e代表存放新Node的节点
            if (e != null) { 
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //e = p.next==null时执行下列代码
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        //evict if false, the table is in creation mode.
        return null;

也就是说，在把Node放入的时候，如果e不为空，会先更新这个Node的value，然后执行afterNodeAccess(e)，相当于对原来的Node的第一次访问，通过这次访问，将这个Node移到最后，并返回旧的value值。

如果e为空，则会执行afterNodeInsertion(evict)，并返回null

LinkedHashMap重写了这两个函数
afterNodeAccess函数是按照访问的顺序管理Node的方法

void afterNodeAccess(HashMap.Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;//Entry是Node的子类
        if (accessOrder && (last = tail) != e) {//如果末尾的Node和e相等，也就没有必要移动，如果不输入accessOrder，默认是false，该方法将不能执行
            //如果用自己输入accessOrder的方法来构造LinkedHashMap，且输入值为true，则这个方法可以按照访问顺序排列
            LinkedHashMap.Entry<K,V> p =                      
                    (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            if (b == null)//如果b为空，a就是链表头
                head = a;
            else
                b.after = a;//把p这个值先抽调，p的前一个node和后一个node直接连起来
            if (a != null)
                a.before = b;//也是先把p抽出来，p的后一个和前一个node直接连起来
            else
                last = b;
            if (last == null)//只要不是第一个元素，tail就不为0，last就算不指向b，也不等于null
                head = p;//如果a为空，b为空，p就是head，同时也是tail
            else {
                p.before = last;//last当前代表上一个访问的元素，把他作为p的前一个
                last.after = p;//p就移动到last的后一个，也就是最新访问的元素，如果要放的Node已经有了，那么这个Node会移动到最后
            }
            tail = p;//The tail (youngest) of the doubly linked list.
            ++modCount;
        }
    }

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);
        }
    }
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;//猜测该方法可能被弃用了
    }

evict只有在构造情况时才是false，其余都是true

但是removeEldestEntry却直接返回false，使得这个函数无法删除节点。当return false；返回true的时候，会把head节点删除掉。

对于HashMap来说，如果key是Interger类，也是会按照顺序输出的。
如果换成其他类型，就会变成无序的。
而LinkedHashMap无论key是什么类，都可以按照输入顺序进行输出，只要accessOrder是false。

下面是一段示例代码

LinkedHashMap<Integer,String> ll=new LinkedHashMap<>(20,0.75f,true);
        //只有用三个参数构造LinkedHashMap，才能改变accessOrder的值，设置为true，可以根据访问顺序管理元素
        for (int i=0;i<10;i++){
            ll.put(i,"对象"+i);
        }
        System.out.println(ll);//直接输出会按照插入的顺序显示
        //for循环已经取代迭代器iterator
        for (Map.Entry<Integer,String> stringStringEntry : ll.entrySet()) {
            System.out.println(stringStringEntry);
        }
        ll.get(2);//访问之后再输出会把访问过的元素移动到最后
        for (Map.Entry<Integer,String> stringStringEntry : ll.entrySet()) {
            System.out.println(stringStringEntry);
        }
        BiConsumer b= (o, o2) -> {
            if (o !=null){
                System.out.println("key :"+o+" "+"value: "+o2);
            }
        };//BiConsumer接口+lambda表达式实现action.accept，对两个参数进行处理
        ll.forEach(b);//(BiConsumer<? super K, ? super V> action)
        Consumer bb= o -> {
            if (o !=null){
                System.out.println("key :"+o+" ");
            }
        };//Consumer接口+lambda表达式实现action.accept，对一个参数进行处理
        ll.entrySet().forEach(bb);//调用Iterator接口的forEach(Consumer<? super T> action)