最近最少使用淘汰策略LRU算法

LRU的介绍我就大致介绍一下吧，也就是如标题说的，最近最少使用的我们就需要舍弃它，可以想象为一个队列，队列头总是最近使用的，队尾总是最以前使用的，如果队列长度大于我们给的的capacity值时，就要舍弃队尾的元素。

我说的可能不清楚，下面的代码也只是记录一下的我自己的一个思路。有错欢迎指正

下面就上代码吧！

/**
 * @author jiezhou
 * @CalssName: LRU2Node
 * @Package com.cn.redis.boot1.redisboot1.utils
 * @Description: 自定义链表node来实现LRU算法
 * @date 2020/11/26/1:00
 */
public class LRU2NodeDemo {
    public static void main(String[] args) {
        LRU2Node lru2Node = new LRU2Node(3);
        lru2Node.put(1, "A");
        lru2Node.put(2, "B");
        lru2Node.put(3, "C");
        lru2Node.put(4, "D");
        lru2Node.put(5, "D");
        lru2Node.put(3, "D");
        lru2Node.listNodes();
    }

    static class LRU2Node<K, V> {
        private Node<K, V> head;//队列头部
        private Node<K, V> tail;//队列尾部
        private int capacity;//因子

        LRU2Node(int capacity) {
            this.capacity = capacity;
        }

        /**
         * 获取链表的长度是否等于capacity,等于了就需要吧tail节点移除，然后再吧当前节点放到头节点，其他后移
         */
        private void put(K key, V value) {
            Node<K, V> newNode = new Node<K, V>(key, value);
            if (head == null) {
                head = newNode;
                tail = newNode;
                return;
            }
            if (getNodeslength(head) >= capacity) {
                //移除最后一个节点
                tail = tail.pre;
                tail.next = null;
            }
            Node node = head;
            head = newNode;
            newNode.next = node;
            node.pre = newNode;
        }

        /**
         * 打印所有节点
         */
        public void listNodes() {
            StringBuilder sb = new StringBuilder();
            if (head == null) {
                return;
            }
            sb.append("[");
            Node node = head;
            do {
                sb.append(" " + node.key + " ");
                node = node.next;
            } while (node != null);
            sb.append("]");
            System.out.println(sb.toString());
        }

        /**
         * 获取节点的长度
         *
         * @param head
         */
        private int getNodeslength(Node head) {

            if (head == null) {
                return 0;
            }
            int length = 1;
            Node node = head;
            while (node.next != null) {
                length++;
                node = node.next;
            }
            return length;
        }
    }

    static class Node<K, V> {
        private K key;
        private V value;
        Node pre;
        Node next;

        Node(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }
}

运行如下：