使用Java实现lru算法详细代码

### 回答1：

LRU算法（Least Recently Used）可以使用Java集合框架中的LinkedHashMap来实现，LinkedHashMap提供了一种按访问顺序排序的功能，具体实现示例如下：import java.util.*;public class LRUCache { // 容量
private int capacity;
// 使用LinkedHashMap保存缓存的内容
private LinkedHashMap<Integer, Integer> cache;

// 构造函数
public LRUCache(int capacity) {
this.capacity = capacity;
cache = new LinkedHashMap<Integer, Integer>(capacity, 0.75f, true){
// 重写removeEldestEntry方法
@Override
protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
return size() > capacity;
}
};
}

// 根据key获取缓存内容
public int get(int key) {
Integer value = cache.get(key);
if (value == null) {
return -1;
} else {
return value;
}
}

// 存入key-value
public void put(int key, int value) {
cache.put(key, value);
}
}

### 回答2：
LRU算法（Least Recently Used，最近最少使用）是一种用于缓存替换策略的算法，它保留最近使用的数据，并淘汰最久未使用的数据。以下是使用Java实现LRU算法的详细代码：

import java.util.HashMap;

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

class LRUCache {
    private int capacity;
    private HashMap<Integer, Node> map;
    private Node head;
    private Node tail;
    
    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.map = new HashMap<>();
        this.head = new Node(0, 0);
        this.tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int key) {
        if (map.containsKey(key)) {
            Node node = map.get(key);
            remove(node);
            addToHead(node);
            return node.value;
        }
        return -1;
    }
    
    public void put(int key, int value) {
        if (map.containsKey(key)) {
            Node node = map.get(key);
            node.value = value;
            remove(node);
            addToHead(node);
        } else {
            if (map.size() == capacity) {
                map.remove(tail.prev.key);
                remove(tail.prev);
            }
            Node newNode = new Node(key, value);
            map.put(key, newNode);
            addToHead(newNode);
        }
    }
    
    private void addToHead(Node node) {
        node.next = head.next;
        node.next.prev = node;
        node.prev = head;
        head.next = node;
    }
    
    private void remove(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
}

本实现使用HashMap来存储缓存数据，HashMap的键为键值，值为对应的Node节点。

LRUCache类有一个构造函数用于初始化缓存容量。get方法用于获取缓存中的值，它首先判断缓存是否包含该键值，如果包含，则将对应的节点移至链表头部并返回对应的值；如果不包含则返回-1。put方法用于存储缓存数据，如果缓存中已存在该键值，则更新对应的值并将对应的节点移至链表头部；如果缓存大小已达到容量上限，则删除最久未使用的节点，并将新节点添加至链表头部。addToHead和remove方法用于调整链表节点的位置，将最近使用的节点移至链表头部，最久未使用的节点移至链表尾部。

以上就是使用Java实现LRU算法的详细代码。

### 回答3：
LRU（最近最少使用）算法是一种缓存淘汰策略，它根据缓存中数据的访问时间来进行淘汰。当缓存已满时，会淘汰掉最近最少使用的数据。下面是使用Java实现LRU算法的详细代码：

import java.util.HashMap;

public class LRUCache {
    private int capacity;
    private HashMap<Integer, Node> cache;
    private Node head;
    private Node tail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        cache = new HashMap<>();
        head = new Node(-1, -1);
        tail = new Node(-1, -1);
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        if (cache.containsKey(key)) {
            Node node = cache.get(key);
            // 将访问的节点移到链表头部
            removeNode(node);
            addToHead(node);
            return node.value;
        }
        return -1;
    }

    public void put(int key, int value) {
        if (cache.containsKey(key)) {
            Node node = cache.get(key);
            node.value = value;
            // 将访问的节点移到链表头部
            removeNode(node);
            addToHead(node);
        } else {
            if (cache.size() == capacity) {
                // 移除最近最少使用的节点
                cache.remove(tail.prev.key);
                removeNode(tail.prev);
            }
            Node newNode = new Node(key, value);
            cache.put(key, newNode);
            addToHead(newNode);
        }
    }

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

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

    private class Node {
        private int key;
        private int value;
        private Node prev;
        private Node next;

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

以上代码实现了一个LRUCache类，里面包含了LRU算法的核心逻辑。LRUCache类有一个构造函数用于初始化缓存容量，get()方法用于获取缓存中的数据，put()方法用于往缓存中添加数据。算法通过双向链表和哈希表实现，双向链表中的节点按照访问顺序从头到尾依次排列，哈希表用于加快查找节点的速度。当缓存已满时，淘汰最近最少使用的节点，即双向链表的尾节点。对于get操作和put操作，都会将访问的节点移到链表头部，保证头部节点是最近访问的节点。这样即可以实现LRU算法的缓存淘汰策略。