单向链表设计LRU缓存

LRU是Least Recently Used的缩写，即最近最久未使用，常用于页面置换算法，是为虚拟页式存储管理服务的。常见的实现是将最近访问过的资源【引用】放一个队列，每次将新访问的放在队首，这样最不常用的就被放到队尾，当达到一定数量后，队尾的对象就被清除。缓存的应用场景很多，尤其是高并发的环境中，可以用来控制request数量。现在以一个单项链表为例，解释下如何来实现一个LRU。

新建一个单向链表

public final class Node{
    String key;
    String value;
    Node next;
    public Node(){};

    public void deleteLastNode(Node previous) {
        if(this.next == null) {
            previous.next = this.next;
        }else{
            this.next.deleteLastNode(this);
        }       
    }
}

final修饰类，表示此类不能再被继承。

LRUCache的实现

一个LRU cacheList需要有一个长度和头节点，且需要实现get和set方法。对于set方法，每次添加一个元素的时候，除了将这个元素放在头节点，如果这个元素已经在cacheList里面，那么需要找出来并删除。

public class LRUCache{
    private int size;
    private Node cacheList;
    public LRUCache(int size){
        this.size = size;
    }

    public String get(String key){
        Node currentNode = cacheList;
        if(key.isEmpty()){
            return null;
        }
        while(currentNode.key != null){
            if(currentNode.key == key){
                return currentNode.value;
            }else{
                currentNode = currentNode.next;
            }
        }
        return null;
    }

    public void set(String key, String value){
        if(!key.isEmpty()){
            int count = 0;
            Node newNode = new Node();
            newNode.key = key;
            newNode.value = value;
            newNode.next = cacheList;
            cacheList = newNode;
            while(newNode.next != null){
                if(newNode.next.key == key){
                    newNode.next = newNode.next.next;
                    break;
                }else{
                    count ++;
                    newNode = newNode.next;
                }
            }       
            if(count >= size -1){
            this.cacheList.
            deleteLastNode(this.cacheList);
            }
        }
    }

    private void printkeys() {
        int count = 0;
        Node currentNode = this.cacheList;
        while(currentNode != null){
            System.out.println("Key-Value pair-" + count + ": " + currentNode.key + " " + currentNode.value);
            count ++;
            currentNode = currentNode.next;
        }       
    }
}

现在来测试一下：

public static void main(String[] args){
    LRUCache testcache = new LRUCache(5);
    testcache.set("A", "A-VALUE");
    testcache.set("B", "B-VALUE");
    testcache.set("B", "B-VALUE");
    testcache.set("C", "C-VALUE");
    testcache.set("D", "D-VALUE");
    testcache.set("E", "E-VALUE");
    testcache.set("F", "F-VALUE");
    testcache.printkeys();
}

结果如下：

几个难点

1. 理解链表的复制

   cacheList = newNode;

   cacheList被赋予了newNode的值，cacheList就记下了newNode的当前值，当newNode再次改变时，cacheList不会改变。

2. 单向链表的节点删除
   巧妙利用this来遍历指定节点。注意，这个方法要定义在Node class里面而不是在LRUCache类中。

   public void deleteLastNode(Node previous) {
       if(this.next == null) {
           previous.next = this.next;
       }else{
           this.next.deleteLastNode(this);
       }       
   }

   另外一种方法可以用来删除任意节点的key：

   public void deleteNode(String key) { 
       if(cacheList.key.equals(key)) { 
           if(cacheList.next != null) {
               cacheList= cacheList.next;
           }else{
               cacheList = null;
           }
       }else {
           cacheList.next.delete(this.cacheList, key);
       }
   }

   在Node类里面就要定义这个方法：

   public void delete(Node previous, String key){
       if(this.key.equals(key)) {
           previous.next = this.next;
       }else {
           if(this.next != null) {
               this.next.delete(this, key);
           }
       }
   }