手写LRU算法

package com.study;

import java.util.HashMap;

/***
 * 底层HashMap + 各个node用指针连接起来，将最新加入或者最新访问的node放在队列的右端，这样队列左端将是最“老”的node，内存不够时，从最左端淘汰元素。
 * @author: 码出地球
 */
public class LRUCache<K, V> {

    private HashMap<K,Node> cache = new HashMap<>();

    Node left = new Node();
    Node right = new Node();

    public LRUCache(){
        this.left.next = right;
        this.right.pre = left;
    }

    class Node{
        V value;
        Node pre;
        Node next;

        public Node(){}

        public Node(V value){
            this.value = value;
        }
    }

    /***
     * 新添加的node放在队列的最右边
     * 左 <=> node1 <=> node2 <=> node3 <=> 右
     *
     * 左 <=> node1 <=> node2 <=> newNode <=> 右
     * @param key
     * @param value
     * @description:
     * 这里只简单的处理了put新元素，当key存在时覆盖，且移到最右端的没有实现 ||_||
     */
    public void put(K key, V value){
        Node node = new Node(value);

        Node temp = right.pre;

        temp.next = node;
        node.next = right;
        node.pre = temp;
        right.pre = node;

        cache.put(key, node);
    }

    /***
     * 例如node1被访问，移到队列的最右边
     * 左 <=> node1 <=> node2 <=> node3 <=> 右
     *
     * 左 <=> node2 <=> node3 <=> node1 <=> 右
     * @param key
     */
    public Node get(K key){
        Node node = cache.get(key);

        node.pre.next = node.next;
        node.next.pre = node.pre;


        Node temp = right.pre;

        temp.next = node;
        node.next = right;
        node.pre = temp;
        right.pre = node;


        return node;
    }

    public String toString(){
        String result = "";

        Node flag = left.next;
        while (flag != null && flag != right){
            result += flag.value.toString() + " ";
            flag = flag.next;
        }

        return result;
    }
}