What is an LRU Cache and how do I implement it in Java?

What is an LRU Cache and how do I implement it in Java?

An LRU (Least Recently Used) Cache is a data structure that stores a limited number of items and evicts the least recently used item when the limit is reached. In Java, you can implement it using a combination of a HashMap and a doubly linked list.

Can you show me a simple implementation of an LRU Cache in Java?

Sure! Here's a basic implementation:

import java.util.*;

class LRUCache {
    private final int capacity;
    private final Map<Integer, Node> map;
    private final DoublyLinkedList list;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.map = new HashMap<>();
        this.list = new DoublyLinkedList();
    }

    public int get(int key) {
        if (!map.containsKey(key)) return -1;
        Node node = map.get(key);
        list.moveToFront(node);
        return node.value;
    }

    public void put(int key, int value) {
        if (map.containsKey(key)) {
            Node node = map.get(key);
            node.value = value;
            list.moveToFront(node);
        } else {
            if (map.size() == capacity) {
                Node lru = list.removeLast();
                map.remove(lru.key);
            }
            Node newNode = new Node(key, value);
            list.addFront(newNode);
            map.put(key, newNode);
        }
    }
}

class Node {
    int key, value;
    Node prev, next;
    public Node(int key, int value) {
        this.key = key;
        this.value = value;
    }
}

class DoublyLinkedList {
    private Node head, tail;

    public DoublyLinkedList() {
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
    }

    public void addFront(Node node) {
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
    }

    public void moveToFront(Node node) {
        remove(node);
        addFront(node);
    }

    public Node removeLast() {
        Node last = tail.prev;
        remove(last);
        return last;
    }

    private void remove(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
}

What are the time complexities for the get and put operations?

Both the get and put operations have a time complexity of O(1) on average, thanks to the HashMap for quick access and the doubly linked list for efficient updates.