深度了解LinkedHashMap

在平时开发的过程中，大部分都是使用HashMap存储key value结构的数据，但是它是没有顺序的，如果你想要一个有顺序的Map，这时候LinkedHashMap就闪亮登场, 本篇文章主要基于jdk1.8学习下LinkedHashMap的功能和原理。在学习LinkedHashMap你需要对HashMap底层实现和源码有一定了解。

介绍

LinkedHashMap是一个有顺序的Hash表，它可以是元素插入顺序或者访问顺序。

• LinkedHashMap最大的特点是有顺序的
• LinkedHashMap的key 和value都可以为空
• LinkedHashMap不是线程安全

 

@Test
    public void test1() {
        // 创建默认的 LinkedHashMap
        Map<String, String> map = new LinkedHashMap<>();
        // 插入
        map.put("1", "1");
        map.put("2", "2");
        map.put("5", "5");
        map.put("4", "4");
        System.out.println(map);
 
        // 访问
        map.get("2");
        map.get("1");
 
        System.out.println(map);
    }

 访问元素后双向链表的顺序维护（afterNodeAccess）
LinkedHashMap中的双向链表默认按元素插入的顺序排列，也可以在构造LinkedHashMap是指定为元素的访问顺序（accessOrder = true）。

afterNodeAccess()方法会在一个元素节点被访问到时被调用，同样该方法在HashMap中为空实现，LinkedHashMap 中覆写了afterNodeAccess()方法。

也就是说，当一个节点被访问时，如果 accessOrder 为 true，则会将该节点移到链表尾部。保证链表尾部是最近访问的节点，那么链表首部就是最近未使用的节点。
 

//在元素被访问时，会调用afterNodeAccess方法，HashMap中的方法为空实现
void afterNodeAccess(Node<K, V> p) {
}


/**
 * LinkedHashMap 中重写的afterNodeAccess方法，用于将被访问到的节点移动到双向链表末尾
 *
 * @param e 被访问的节点
 */
void afterNodeAccess(Node<K, V> e) { // move node to last
    LinkedHashMap.Entry<K, V> last;
    /*如果e不是尾节点，那么尝试移动e到尾部*/
    if (accessOrder && (last = tail) != e) {
        //p记录e，b保存p在大链表中的前驱，a保存p在大链表中的后继
        LinkedHashMap.Entry<K, V> p =
                (LinkedHashMap.Entry<K, V>) e, b = p.before, a = p.after;
        //p的后继置空
        p.after = null;
        //如果b为null，表明p为头节点
        if (b == null)
            //头节点设置为p的后继a
            head = a;
        else
            //否则b的后继设置为a
            b.after = a;
        /*如果a不为null，a的前驱设置为b*/
        if (a != null) {
            a.before = b;
        }
        /*否则，尾节点设置为b*/
        else {
            last = b;
        }
        //如果，last为null
        if (last == null)
            //那么头节点指向p
            head = p;
        else {
            /*否则,将p链接在链表的最后*/
            p.before = last;
            last.after = p;
        }
        //尾节点指向p
        tail = p;
        ++modCount;
    }
}

排序方式 

public class LinkedHashMapTest {

    public static void main(String[] args) throws Exception {
        
        LinkedHashMap map = new LinkedHashMap(16, 0.75f, false);
        map.put(1, 1);
        map.put(2, 2);
        map.put(3, 3);
        map.put(4, 4);
        map.put(5, 5);
        System.out.println("按元素插入顺序："+map.keySet());

        LinkedHashMap map2 = new LinkedHashMap(16, 0.75f, true);
        map2.put(1, 1);
        map2.put(2, 2);
        map2.put(3, 3);
        map2.put(4, 4);
        map2.put(5, 5);
        map2.get(1);
        System.out.println("按元素访问顺序："+map2.keySet());
    }
}

LRU缓存

LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是：如果数据最近被访问过，那么将来被访问的几率也更高。

1 LRU基于链表的实现算法
以链表尾部保存最近访问数据为例 ：

新数据插入到链表尾部；
每当缓存命中（即缓存数据被访问），则将数据移到链表尾部；
指定LRU缓存的容量，当链表长度大于容量时，将链表头部的数据丢弃。
.2 LinkedHashMap与LRU缓存
LinkedHashMap已经提供了基于访问顺序的迭代机制，最近被访问的节点在尾部，最远被访问的节点在头部，并且提供了链表头部的数据丢弃的实现。

.2.1 afterNodeInsertion()方法
由于LRU缓存必然要有容量限制，因此在每次添加完元素之后需要判断，当前元素个数是否大于缓存容量：
 

 

LinkedHashMap的迭代器有三种：

LinkedKeyIterator
LinkedValueIterator
LinkedEntryIterator
他们都继承自LinkedHashIterator抽象类，并且实现了Iterator接口。其中LinkedHashIterator为这些迭代器提供了对Iterator接口方法的基本实现，他们惟一的区别就是next()方法的实现不同。

注意：LinkedHashMap的三种迭代器都是快速失败（fail-fast）的。