Java集合之LinkedHashMap实现LRU缓存

 LinkedHashMap在HashMap的基础上，又将所有节点通过双向链表组织在一起，默认按照节点插入顺序构建链表
当设置accessOrder为true时，则每访问一个节点，要将此节点在链表中移动到尾部，根据此特性能够通过

LinkedHashMap实现LRU缓存。

 HashMap中有三个空方法，LinkedHashMap继承了HashMap，并利用这三个方法实现组织链表

// HashMap中
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }

// LinkedHashMap中
void afterNodeRemoval(Node<K,V> e) { // 将节点从链表中删除操作
    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;
}

// evict代表是否驱逐“最旧”的节点，此值只有在初始化哈希表时为false
void afterNodeInsertion(boolean evict) { // 满足一定条件，将删除链表中头结点（最旧）
    LinkedHashMap.Entry<K,V> first;
    if (evict && (first = head) != null && removeEldestEntry(first)) { // LinkedHashMap中removeEldestEntry方法默认实现返回false
        K key = first.key;
        removeNode(hash(key), key, null, false, true);
    }
}

void afterNodeAccess(Node<K,V> e) { // 如果设置了按访问顺序构建链表，则访问某个节点后，要将其移动到链表尾成为最近访问节点
    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;
    }
}

 LinkedHashMap中的节点对HashMap中的节点进行了扩展，增加了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);
    }
}

 在LinkedHashMap中添加新节点是，在创建新节点后，立刻将其加入双向链表：

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

LRU实现：

import java.util.LinkedHashMap;
import java.util.Map;

public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {
    private int lruCapacity; // LRU缓存容量

    public LRULinkedHashMap() {
        this(1024, 0.75f);
    }

    public LRULinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor, true); // accessOrder始终为true
        this.lruCapacity = (int) (initialCapacity * loadFactor) - 1; // lruCapacity小于阈值，哈希表不会进行重哈希操作
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > lruCapacity; // 当哈希表中节点（键值对）数量超出缓存容量，返回true，删除双向链表头结点
    }

    public static void main(String[] args) {
        Map<Integer, String> map = new LRULinkedHashMap<>(8, 0.75f);
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        map.put(4, "d");
        map.put(5, "e");
        map.put(6, "f");
        System.out.println(map); // {1=a, 2=b, 3=c, 4=d, 5=e, 6=f} // 默认按照put顺序
        System.out.println(map.get(3)); // c
        System.out.println(map); // {1=a, 2=b, 4=d, 5=e, 6=f, 3=c} // 访问key=3节点后，该节点被移动到链表尾
        map.put(1, "x");
        System.out.println(map); // {2=b, 4=d, 5=e, 6=f, 3=c, 1=x} // 更新key=1节点后，该节点被移动到链表尾
        map.put(7, "g");
        System.out.println(map); // {4=d, 5=e, 6=f, 3=c, 1=x, 7=g} // 添加key=7节点后，缓存容量超出限制（8*0.75=6），表头节点(key=2)被删除
    }
}