How can I implement an LRU Cache in Java?

How can I implement an LRU Cache in Java?

You can implement an LRU Cache in Java using a combination of a HashMap and a doubly linked list. The HashMap will store the keys and their corresponding node references, while the doubly linked list will maintain the order of usage.

Can you provide a code example for that?

Sure! Here's a simple 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.addFirst(newNode);
            map.put(key, newNode);
        }
    }
}

What are the advantages of using an LRU Cache?

The advantages of using an LRU Cache include improved performance by keeping frequently accessed data in memory, reduced latency for data retrieval, and efficient memory usage by evicting the least recently used items.