LRUCache算法实现

package LRUCacheDemo;

import java.util.HashMap;

/**
 * @ClassName LRUCacheDemo
 * @Description
 * @Version 1.0
 */
public class LRUCacheDemo {
    public class Node{
        int key,val;
        Node pre;
        Node next;
        public Node(int key,int val){
            this.key = key;
            this.val = val;
        }
    }
    public class  DoubleListNode{
        Node head;
        Node tail;
        int size;
        public DoubleListNode(){
            //没有初始化头尾节点！！！
            //补上===========================
            head=new Node(0,0);//标记不存数据
            tail = new Node(0,0);
            //=============================
            head.next=tail;
            tail.pre=head;
            //没有初始化容量！！！
            //====================
            size=0;
            //====================
        }
        //删除指定节点,返回该节点
    public Node delNode(Node node){
        node.pre.next=node.next;
        node.next.pre=node.pre;
        size--;//这里因为put操作需要判断是否溢出，所以要引入size统计链表长度
        return node;
    }
        //删除头节点,返回该节点
        public Node delFirst(){
        //判断双相钢链表是否为空
            if (head.next==tail){
                return null;
            }
        Node firstNode=head.next;
            delNode(firstNode);
            //size--;这里不用size--,因为在delNode()已经--过了！！！
            return firstNode;
        }

        //尾插发添加节点
        public void addTail(Node node){
            node.pre=tail.pre;
            node.next=tail;
            tail.pre.next=node;
            tail.pre = node;
            size++;
        }
        public int size() {
            return size;
        }


    }

    int capacity;
    HashMap<Integer,Node> map;
    DoubleListNode cache;
    public LRUCacheDemo(int capacity){
        this.capacity = capacity;
        map = new HashMap<Integer, Node>();
        cache=new DoubleListNode();
    }
    //设置最近使用的元素
    public void makeRecently(int key){
        Node node=map.get(key);
        //删除旧的节点
        cache.delNode(node);
        //节点尾插法到链表
        cache.addTail(node);
    }
    public int get(int key){
        if (!map.containsKey(key)){
            return -1;
        }
        //将该节点设置为最近使用的节点
        makeRecently(key);
        //返回该节点的value
        return map.get(key).val;
    }

    public void put(int key, int value){
        //判断是否包含key
        if (map.containsKey(key)){
            //覆盖value，更新map，设置为最新更新元素
            map.get(key).val=value;
            makeRecently(key);
            return;
        }
        //如果不包含，需要添加
        //判断是否溢出
        int flag=cache.size();
        while (capacity<=flag){
            //删除头节点,删除map中的键值对
            Node firstNode=cache.delFirst();
            map.remove(firstNode.key);
            flag--;
        }
        //添加新的元素
        Node node=new Node(key,value);
        map.put(key, node);
        //将新元素设置为最近使用元素
        //makeRecently(key);注意，这里不能使用设置为最近使用元素方法
        //因为该方法是将map中已存在的KV设置为最近使用元素。
        //对于不存在的key我们需要手动添加到双向链表末尾
        cache.addTail(node);
    }
}