题目

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。 实现 LRUCache 类：

LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

来源：力扣（LeetCode） 链接：leetcode-cn.com/problems/lr…

解法一、运用LinkedHashMap实现

class LRUCache {
    // 最大容量
    int cap;
    //LUR的关键：哈希链表 
    LinkedHashMap<Integer,Integer> cache = new LinkedHashMap<>();
    public LRUCache(int capacity) {
        // 官方说法：this首先是一个对象,它代表调用这个函数的对象
        this.cap = capacity;
        // cache.cap = capacity;会报错，cannot find symbol

    }
    
    public int get(int key) {
        if (!cache.containsKey(key)){
            return -1;
        }
        // 调用了，所以把key置为最近使用
        makeRencently(key);
        return cache.get(key);
    }
    
    public void put(int key, int value) {
        // 如果已经包含key，先修改key的值，再将它变为最近使用
        if(cache.containsKey(key)){
            // 修改key的值（因为key的唯一性，放入的时候回自动覆盖原来的value）
            cache.put(key,value);
            // 再将它变为最近使用
            makeRencently(key);
            return;
        }
        // 如果超过了储存量，则删除头节点（因为实现的是尾插入，所以头结点就是最久没有用的，删去）
        if (cache.size() >= this.cap){
            // 获取头结点
            // Map中所有的键存入到set集合中。因为set具备迭代器。所有可以迭代方式取出所有的键
            // 使用.iterator()迭代器后的指针其实指向的是第一个元素的上方，即指向一个空
            // .next()指针下移一位，指向头节点。hasNext方法的，判断下一个元素的有无，并不移动指针
            int oldestKey = cache.keySet().iterator().next();
            //删去头结点
            cache.remove(oldestKey);
        }
        // 放入，将新的key添加到链表尾部
        cache.put(key,value);
    }
    // 将节点移到链表尾部，变为最近使用
    public void makeRencently(int key){
        // 获取key对应的值
        int val = cache.get(key);
        // 删除key,重新插入队尾
        cache.remove(key);
        cache.put(key,val);
    }
}

二、自己构建双链表

思路

一、LUR实现功能

通过哈希链表来实现： 1、时序：每次向尾部添加元素，尾巴为最新使用，头为最早使用

2、快速查找：通过key可以快速查找对应的value值

3、快速插入删除：内存满了之后自动删除头，插入尾巴，

主要就是： Node类：双链表节点定义，储存key和value，next和prev指针

DoubleList类：伪头尾节点，主要有四个函数（方法）：在尾部添加、删除、删除头部节点（最晚使用的）、得到size

LUR类：有6个函数：两个主方法：get和put，和避免直接对map和双链表细节进行操作的4个API：提到尾部、向尾部增加、删除、内存满了的时候释放头

代码

// 首先，写出双链表节点,为了简化，key 和val都设置为int
// 双链表节点的设置
class Node{
    // 节点包含两个值，key和val
    public int key,val;
    // 两个指针，next和prev
    public Node next,prev;
    public Node(int k,int v){
        // this表示对象
        this.key = k;
        this.val = v;
    }
}
// 然后依靠Node类型构建双链表，实现LUR算法的机构API
class DoubleList{
 // 构建伪头、尾节点（0,0）作为边界，这样在对节点进行操作时就不需要检查相邻节点是否存在，方便操作
// size 表征双链表的大小
// 双链表实现LRU共需要四个方法：在尾部添加、删除、删除头部节点（最晚使用的）、得到大小
    private Node head,tail;
    private int size;
    public DoubleList(){
        head = new Node(0,0);
        tail = new Node(0,0);
        head.next = tail;
        tail.prev = head;
        size = 0;
    }
// 增加节点到尾巴主要是四步：改这个节点的next、prev指针指向、将最后一个节点next指针指向它，将tail的prev指针指向它
    public void addLast( Node x){
        x.next = tail;
        x.prev = tail.prev;
        tail.prev.next = x;
        tail.prev = x;
        size++;
    }
    public void remove(Node x){
        x.prev.next = x.next;
        x.next.prev = x.prev;
        size--;
    }
    // 返回头结点是为了能够在map中查找到，这也是为什么双链表也需要储存key
    // 因为删除头的时候需要返回key才能在map中也删掉
    // 为什么不需要size--呢
    public Node removeFirst(){
        if (head.next == tail){
            return null;
        }
        Node first = head.next;
        remove(first);
        // size--;
        return first;
    }
    public int size(){
        return size;
    }
    
}
class LRUCache {
    private HashMap<Integer,Node> map =new HashMap<>();
    private DoubleList cache = new DoubleList();
    private int cap;
    public LRUCache(int capacity) {
        this.cap = capacity;
    }
    // 为了避免LRU中的主方法get和put直接操作map和cache细节
    // 先实现几个函数，在这两种数据结构上提供一层抽象API
    // 将调用过的提到尾部、向尾部增加、删除、内存满了的时候释放头
    // 主方法：get 调用之后把它放到尾巴，返回值
     public int get(int key) {
        if(!map.containsKey(key)){
            return -1;
        }
        makeRecently(key);
        return map.get(key).val;
    }
    
    // 主方法：put 已经有了的话先删除，再在尾巴加入，内存满的话先释放头，再在尾巴加入
    public void put(int key, int value) {
        // Node x = new Node(key,value);
        if(map.containsKey(key)){
            // cache.put(x)
            deleteKey(key);
            addRecently(key,value);
            return;
        }
        if(cap == cache.size()){
            removeLeastRecently();
        }
        addRecently(key, value);
    }

       private void makeRecently(int key){
        Node x = map.get(key);
        cache.remove(x);
        cache.addLast(x);
    }
    private void addRecently(int key,int value){
        Node x =new Node(key,value);
        cache.addLast(x);
        map.put(key, x);
    }
    private void deleteKey(int key){
        Node x = map.get(key);
        cache.remove(x);
        map.remove(key);
    }
    
    public void removeLeastRecently(){
        Node x = cache.removeFirst();
        int k = x.key;
        map.remove(k);
    }
 }
/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */