LRU缓存机制（利用ArrayDeque和map不会超时）（只能自己实现一个能够双向链表）

题目

更快的代码（自己定义一个双端结点Node，形成一个LRU式的链表（有两个伪头head和伪尾结点tail），还用到了map（注意： map中存的是 key 和 Node）

class LRUCache {
        int size = 0;
        int capacity;

        class Node{
            Node pre;
            Node next;
            int key;
            int value;
            Node(){

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

        Map<Integer,Node> map = new HashMap<>();
        Node head;  //伪头结点
        Node tail;  //伪尾结点
    public LRUCache(int capacity) {
            this.capacity = capacity;
            head = new Node();
            tail = new Node();
            head.next = tail;
            head.pre = null;
            tail.pre = head;
            tail.next = null;
    }
    
    public int get(int key) {
        Node tNode = map.get(key);
        if(tNode == null)   return -1;
        removeToHead(tNode);
        return tNode.value;
    }
    private void removeToHead(Node tNode){
        removeNode(tNode);
        addToHead(tNode);
    }
    private void   removeNode(Node tNode){
        tNode.next.pre = tNode.pre;
        tNode.pre.next= tNode.next;
    }
    private void   addToHead(Node tNode){
        tNode.next = head.next;
        head.next.pre = tNode;
        head.next = tNode;
        tNode.pre = head;
    }

    public void put(int key, int value) {
        Node tNode = map.get(key);
        if(tNode == null){ //代表原先不存在该记录，则新建后添加到 双向链表中（双向链表其实就是LRU缓存）
            size++;         // 如果是创建新年记录的话，别忘了 size++
            Node newNode  = new Node(key,value);
            map.put(key,newNode);
          //然后判断是否超过了 能容纳的 容量
            if(size > capacity){
                removeTail();       // 这里面实现了 size减一 的操作
                addToHead(newNode);
            }else{  //未超过容量，直接添加到 双向链表表头
                addToHead(newNode);
            }
        }else{ // 原先就存在该记录，只需更新该节点的value ，然后在 双向链表中 将该节点移动到 链头 即可
            tNode.value = value;
            removeToHead(tNode);
        }
    }

    private void removeTail(){
        map.remove( tail.pre.key );   //一定要在map中删除该记录信息，要不然会读脏数据
        size--;     // 移除了最后一个结点（其实是伪尾结点前面的一个结点）， LRU的现有的元素个数 size 要 减一
        tail.pre = tail.pre.pre;
        tail.pre.next = tail;
    }
}

我的代码（利用ArrayDeque实现的queue，不会超时）

class LRUCache {
    int capacity;
    Map<Integer, Integer> map;
    // 队头的元素是上次访问距今最久的，队尾是最近刚刚访问的, 访问就是put、get操作
    Queue<Integer> queue;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.map = new HashMap<>();
        this.queue = new ArrayDeque<>();
    }
    
    public int get(int key) {
        if ( map.containsKey(key) ) {
            // 将该key移到表尾，代表最近访问过
            // 注意，必须是Integer，int传进去代表index
            queue.remove(Integer.valueOf(key));
            queue.add(key);
            return map.get(key);
        } else {
            return -1;
        }
    }
    
    public void put(int key, int value) {
        // put操作，算作一次访问
        if ( map.containsKey(key) ) {
            queue.remove(Integer.valueOf(key));
        } else {
            // 容量满了，从map中剔除queue头的元素
            if ( this.capacity == map.size() ) {
                int cur = queue.remove();
                map.remove(cur);
            }
        }
        map.put(key, value);
        queue.add(key);
    }
}

做第四遍，发现自己一些易错的地方，已经在注释中表明

class LRUCache {


    Queue<Integer> q;
    Map<Integer,Integer> map;
    int capacity;
    public LRUCache(int capacity) {
         map = new HashMap<>();
         q = new ArrayDeque<>();
        this.capacity = capacity;
    }
    
    public int get(int key) {
       if(map.containsKey(key)){
           q.remove(key);
           q.add(key);
           return map.get(key);
       }
       return -1;
    }
    
    public void put(int key, int value) {
        if(!map.containsKey(key)){
            map.put(key,value);
            if(q.size()<capacity){
                q.add(key);
                return;
            }
            // 队列满了，出队的时候，map也要移除相应的键值对啊，要不然还能查到失效的元素
            int remove = q.remove();
            map.remove(remove);
            q.add(key);
            return;
        }
        q.remove(key);
        q.add(key);
        map.put(key,value);
        return;

    }
}