java LinkedhashMap 撘箄蓮撖寡情

前言：借助LinkedHashMap，我们可以实现LRU的流程。它内部实现是一个双向链表，是有序的，可以根据数据的访问顺序存储数据，最近访问的数据别放在链表尾部，前提是在初始化的时候指定访问顺序。因此，对应于LRU算法，在查询时，如果命中（访问）就会自动调整到尾部，如果没命中，直接放在尾部即可，若超过指定容量大小，要对头部元素进行移除，这里我们只需要重写LinkedHashMap的removeEldestEntry方法即可。

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

public class LRU {
    static Scanner in = new Scanner(System.in);
	public static void main(String[] args) {
//		LinkedList<> st = new LinkedList<Integer>();
		
		LRUList<Integer,Integer> mp = new LRUList<Integer, Integer>(5, 0.75f, true) ;
		for (int i = 1; i <= 5; i++) {
			mp.put(i, i);
		}
		for (Map.Entry e:mp.entrySet()) {
			System.out.println(e.getKey());
		}
		System.out.println("----------------");
		int key;
		while(in.hasNext()) {
			key = in.nextInt();
			if(mp.containsKey(key)) mp.get(key);
			else mp.put(key, key);
			for (Map.Entry e:mp.entrySet()) {
				System.out.println(e.getKey());
			}
			System.out.println("----------------");
		}
	}

}
class LRUList<K,V> extends LinkedHashMap<K,V>{
	int size;
	public LRUList(int initcap,float loadfactor,boolean order) {
		super(initcap, loadfactor, order);
		this.size = initcap;
	}
     @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
    	if(size()>size) return true;
    	else return false;
    } 	
}

拓展：若不能使用这个现成的结构，我们可以自己定义一个方法，使用Hashmap+双向链表的方式即可，Hashmap可以达到O(1)的查找复杂度，稍后更新这部分代码。

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class LRUCache {

    private Map<Integer, ListNode> map;

    /**
     * 双链表结点类
     * 链表头部代表最常访问的节点
     */
    private class ListNode {

        private Integer key;
        private Integer value;

        private ListNode pre;
        private ListNode next;

        public ListNode() {
        }

        public ListNode(Integer key, Integer value) {
            this.key = key;
            this.value = value;
        }
    }

    private int capacity;//容量超过删除

    /**
     * 虚拟头结点没有前驱
     */
    private ListNode dummyHead;
    /**
     * 虚拟尾结点没有后继
     */
    private ListNode dummyTail;

    public LRUCache(int capacity) {
        map = new HashMap<>(capacity);
        this.capacity = capacity;
        dummyHead = new ListNode(-1, -1);
        dummyTail = new ListNode(-1, -1);
        // 初始化链表为 head <-> tail

        dummyHead.next = dummyTail;
        dummyTail.pre = dummyHead;
    }

    /**
     * 命中缓存，将此节点移到链表头部并返回值
     * @param key
     * @return
     */
    public int get(int key) {
        if (map.containsKey(key)) {
            ListNode node = map.get(key);
            int val = node.value;

            // 把当前 node 移动到双向链表的头部
            moveNode2Head(key);
            return val;
        } else {
            return -1;
        }
    }

    /**
     * 发生缺页，则添加新的节点进来
     * 如果哈希表的容量满了，就要删除一个链表末尾元素
     * 然后将新节点在链表头部插入
     *
     * @param key
     * @param value
     */
    public void put(int key, int value) {
        //key 需要更新时使用
        if (map.containsKey(key)) {
            map.get(key).value = value;
            //把当前 node 移动到双向链表的头部
            moveNode2Head(key);
            return;
        }

        // 放元素的操作是一样的

        if (map.size() == capacity) {
            // 如果满了
            ListNode oldTail = removeTail();

            // 设计 key 就是为了在这里删除
            map.remove(oldTail.key);
        }

        // 然后添加元素
        ListNode newNode = new ListNode(key, value);
        map.put(key, newNode);
        addNode2Head(newNode);
    }

    // 为了突出主干逻辑，下面是 3 个公用的方法

    /**
     * 删除双链表尾部结点
     */
    private ListNode removeTail() {
        ListNode oldTail = dummyTail.pre;
        ListNode newTail = oldTail.pre;

        // 两侧结点建立连接
        newTail.next = dummyTail;
        dummyTail.pre = newTail;

        // 释放引用
        oldTail.pre = null;
        oldTail.next = null;

        return oldTail;
    }

    /**
     * 把当前 key 指向的结点移到双向链表的头部
     *
     * @param key
     */
    private void moveNode2Head(int key) {
        // 1、先把 node 拿出来
        ListNode node = map.get(key);

        // 2、原来 node 的前驱和后继接上
        node.pre.next = node.next;
        node.next.pre = node.pre;

        // 3、再把 node 放在末尾
        addNode2Head(node);
    }

    /**
     * 在双链表的头部新增一个结点
     *
     * @param newNode
     */
    private void addNode2Head(ListNode newNode) {
        // 1、当前头结点
        ListNode oldHead = dummyHead.next;

        // 2、末尾结点的后继指向新结点
        oldHead.pre = newNode;

        // 3、设置新结点的前驱和后继
        newNode.pre = dummyHead;
        newNode.next = oldHead;

        // 4、更改虚拟头结点的后继结点
        dummyHead.next = newNode;
    }


    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        LRUCache cache = new LRUCache(3);
        cache.put(1, 1);
        cache.put(2, 2);
        cache.get(2);
        cache.put(3,3);
        cache.put(4,4);
        cache.get(2);
        ListNode head = cache.dummyHead;
        head = head.next;
        while (head!=cache.dummyTail){
            System.out.println(head.value);
            head = head.next;
        }

    }
}