LRU缓存淘汰算法实现

利用一个链表存储所有的节点
hashMap存储key和节点之间的对应关系

public class Node {

    int key,val;

    public Node next,pre;

    public Node(int key, int val) {
        this.key = key;
        this.val = val;
    }
}

public class DoubleList {


    private Node head, tail;

    private int size;

    public DoubleList() {
        head = new Node(0, 0);
        tail = new Node(0, 0);

        head.next = tail;
        tail.pre = head;
        size = 0;
    }

    public void addLast(Node node) {

        node.pre = tail.pre;
        node.next = tail;

        tail.pre.next = node;
        tail.pre = node;
        size++;
    }

    public Node removeFirst() {

        if (head.next == null) {
            return null;
        }
        Node first = head.next;
        remove(first);

        return first;
    }

    public void remove(Node node) {

        node.pre.next = node.next;
        node.next.pre = node.pre;

        node.pre = null;
        node.next = null;
        size--;
    }

    public int getSize() {
        return size;
    }

}

public class LRUCache {


    private Map<Integer,Node> map;
    private DoubleList cache;
    private int capCity;

    public LRUCache(int capCity) {
        this.capCity = capCity;
        map=new HashMap<>();
        cache=new DoubleList();
    }

    private void makeRecentLy(int key){

        Node node=map.get(key);
        cache.remove(node);
        cache.addLast(node);

    }

    private void addRecentLy(int key,int val){
        Node node=new Node(key,val);
        map.put(key,node);
        cache.addLast(node);
    }

    private void deleteKey(int key){

        Node node=map.get(key);

        cache.remove(node);
        map.remove(node.key);

    }

    private void removeLastRecently(){

        Node deleteNode=cache.removeFirst();

        map.remove(deleteNode.key);
    }


    public int get(int key) {

        if (map.get(key)==null){
            return -1;
        }

        makeRecentLy(key);
        return map.get(key).val;

    }

    public void put(int key, int value) {

        if (map.get(key)!=null){
            deleteKey(key);
            addRecentLy(key,value);
            return;
        }

        if (capCity==cache.getSize()){
            removeLastRecently();
        }

        addRecentLy(key,value);

    }
    
}