2021-2-23:最近最少使用缓存实现

import java.util.Hashtable;
public class LRUCache{
    static class CacheNode {
        Object key,val;
        CacheNode pre,next;
        public CacheNode(Object key, Object val){
            this.key = key;
            this.val = val;
        }
    }


    static class DoubleList{
        int size;
        CacheNode head,tail;

        public void addFirst(CacheNode node){
            if (head == null) {
                head = tail = node;
            }else {
                node.next = head;
                head.pre = node;
                head = node;
            }
            size++;
        }

        public void remove(CacheNode node){
            if (head == tail) {
                head = tail = null;
            }else if (node.key == tail.key){
                final CacheNode p = tail.pre;
                tail.pre.next = null;
                tail.pre = null;
                tail = p;
            }else if (node.key == head.key) {
                final CacheNode n = head.next;
                head.next.pre = null;
                head.next = null;
                head = n;
            }else {
                node.pre.next = node.next;
                node.next.pre = node.pre;
                node.next = node.pre = null;
            }
            size--;
        }

    }


    Hashtable<Object, CacheNode> map;
    DoubleList cache;
    int capacity;

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

    public Object get(Object key){
        if (map.containsKey(key)) {
            Object val = map.get(key).val;
            put(key,val);
            return val;
        }else {
            return null;
        }
    }

    public void put(Object key,Object val){
        final CacheNode node = new CacheNode(key,val);
        if (map.containsKey(key)) {
            cache.remove(map.get(key));
        }else {
            if (capacity == cache.size) {
                System.out.println("移除key:"+cache.tail.key);
                map.remove(cache.tail.key);
                cache.remove(cache.tail);
            }
        }
        cache.addFirst(node);
        map.put(key,node);
    }
    public int  size(){
        return cache.size;
    }
}