实现一个LRU 算法

lru 这种算法一般用于缓存过期策略，这里用一个hashmap和node这两种数据结构实现，代码如下

import java.util.HashMap;
import java.util.Map;

public class LRU {
    private Node head;//记录下一个要移除的node
    private Node end;//记录插入的尾巴节点
    private Map<String, Node> map=new HashMap<>();//加快查找速度，不用遍历链表，时间复杂度为O(1)
    private int limit;//最大容量

    public LRU(int limit) {
        this.limit = limit;
    }

    public void add(String key , String val) {
        Node node = map.get(key);
        if(node == null){
            if(map.size() >= limit){
                map.remove(head.key);
                removeNode(head);
            }
            Node newNode = new Node(key, val);
            map.put(key,newNode);
            addNode(newNode);
        }else {
            reflush(node);
        }
    }

    @Override
    public String toString() {
        return "LRU{" +
                "map=" + map +
                ", limit=" + limit +
                '}';
    }

    public void remove(String key) {
        Node node = map.remove(key);
        removeNode(node);
    }
    public String get(String key) {
        Node node = map.get(key);
        if(node == null){
            return null;
        }
        reflush(node);
        return node.val;
    }
    private void reflush(Node node) {
        if(node == end){
            return;
        }
        removeNode(node);
        addNode(node);
    }

    private void removeNode(Node node) {
        boolean isHeadOrEnd=false;
        if(node == end){
            end=end.pre;
            isHeadOrEnd=true;
        }
        if(node == head){
            head=head.next;
            isHeadOrEnd=true;
        }
        if(isHeadOrEnd){
            return;
        }
        if(node.next != null){
            node.next.pre=node.pre;
        }
        if(node.pre != null){
            node.pre.next=node.next;
        }
    }

    private void addNode(Node newNode) {
        if(end != null){
            end.next=newNode;
            newNode.pre=end;
        }
        end=newNode;
        if(head == null){
            head=end;
        }
    }
}
/*这里用双向队列，在移除时需要改变node的指向，如果不是双端队列，会比较麻烦*/
class Node{
    public String key;
    public String val;
    public Node pre;
    public Node next;

    public Node(String key, String val) {
        this.key = key;
        this.val = val;
    }
}

参考

转载于:https://my.oschina.net/u/3574106/blog/3067820