LRU算法java实现

class LRUCache {

    Entry head, tail;
    int capacity;
    int size;
    Map<Integer, Entry> cache;

    public static class Entry {
        int key;
        int value;
        Entry pre;
        Entry next;
        public Entry() {}
        public Entry(int _key, int _value) {key = _key; value = _value;}
    }

    public LRUCache(int capacity) {
        this.capacity = capacity;
        initLinkedList();
        size = 0;
        cache = new HashMap<>(capacity + 2);
    }

    private void initLinkedList() {
        head = new Entry();
        tail = new Entry();
        head.next = tail;
        tail.pre = head;
    }
    
    public int get(int key) {
        Entry node = cache.get(key);
        if (node == null) {
            return -1;
        }
        moveNode(node);
        return node.value;
    }
    
    public void put(int key, int value) {
        Entry node = cache.get(key);
        if (node != null) {
            node.value = value;
            moveNode(node);
            return;
        }
        if (size == capacity) {
            Entry lastNode = tail.pre;
            deleteNode(lastNode);
            cache.remove(lastNode.key);
            size--;
        }

        Entry newNode = new Entry();
        newNode.key = key;
        newNode.value = value;
        addNode(newNode);
        cache.put(key, newNode);
        size++;
    }

    private void moveNode(Entry node) {
        deleteNode(node);
        addNode(node);
    }

    private void addNode(Entry node) {
        head.next.pre = node;
        node.next = head.next;

        head.next = node;
        node.pre = head;
    }

    private void deleteNode(Entry node) {
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }
}