LRU缓存(JAVA实现)

LRU最近最久未使用

两种实现方法

第一种是 利用hashmap加双向链表完成模拟操作

• 代码如下

class LRUCache {
    class DLinkedList{ //这里是定义的双向链表
        int val;
        int key;
        DLinkedList next;
        DLinkedList pre;
        public DLinkedList(int key, int val){
            this.key = key;
            this.val = val;
        }
    }
    Map<Integer,DLinkedList> map = new HashMap<>(); //使用hashmap每个key存一个对应的DLinkedList（key，value）；
    DLinkedList head = new DLinkedList(0,0);
    DLinkedList tail = new DLinkedList(0,0);
    int capacity;
    public LRUCache(int capacity) {
        this.capacity = capacity;
        head.next = tail;
        tail.pre = head;
    }
    public int get(int key) {
        if(map.containsKey(key)){
            DLinkedList node = map.get(key);
            delet(node);
            insert(node);
            return node.val;
        }else{
            return -1;
        }
    }
    
    public void delet(DLinkedList node){//删除节点
        node.next.pre = node.pre;
        node.pre.next = node.next;
        node.next = null;
        node.pre =null;
    }
    public void insert(DLinkedList node){//插入到最后面
            node.next = tail;
            node.pre = tail.pre;
            tail.pre.next = node;
            tail.pre = node;
    }

    public void put(int key, int value) {
        if(map.containsKey(key)){
            DLinkedList node = map.get(key);
            node.val = value;//对加入的数据更新
            delet(node);
            insert(node);
        }else{
            if(capacity==0){
                map.remove(head.next.key);//删除最近最久没有使用的；
                delet(head.next);//从双向链表中删除；
                capacity++;
            }
            DLinkedList node  = new  DLinkedList(key,value);
            map.put(key,node);
            insert(node);
            capacity--;
        }
    }
}

第二种方法 直接继承LinkedHashMap重写定义容量大小即可

class LRUCache extends LinkedHashMap<Integer,Integer>{
    private int capacity;
    public LRUCache(int capacity) {  
         super(capacity,0.75F,true);
         this.capacity = capacity;
    }
    public int get(int key) { 
        return super.getOrDefault(key,-1);
    }
    
    // public void put(int key, int value) {
    //     super.put(key,value);
    // }

    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer,Integer> eldest){
        return size() > capacity; 
    }

}