基于单链表实现LRU

import java.util.Scanner;

public class LRUBaseLinkedList<T> {

    private final static Integer DEAULT_CAPACITY = 10;

    private SNode<T> headNode;

    //链表长度
    private Integer length;

    //链表容量
    private Integer capacity;

    public LRUBaseLinkedList() {
        this.headNode = new SNode<>();
        this.capacity = DEAULT_CAPACITY;
        this.length = 0;
    }

    public LRUBaseLinkedList(Integer capacity){
        this.headNode = new SNode<>();
        this.capacity = capacity;
        this.length = 0;
    }

    /**
     * LRU核心算法:
     * 查找元素在链表中是否存在，如果存在，删除该元素，并将该元素插入到链表头部
     * 如果不存在，判断链表是否已满，满的话删除末尾元素；然后将该元素插入到链表头部
     * @param data
     */
    public void add(T data){
        SNode preNode = findPreNode(data);

        //如果链表中存在，删除原数据，再插入到链表的头部
        if(preNode != null){
            deleteElemNext(preNode);
            insertElemAtBeign(data);
        }else{
            //如果缓存已满
            if(length >= this.capacity){
                deleteElemAtEnd();
            }
            insertElemAtBeign(data);
        }
    }

    //删除preNode节点的下一个节点
    private void deleteElemNext(SNode preNode){
        SNode temp = preNode.getNext();
        preNode.setNext(temp.getNext());
        temp = null;
        length --;
    }

    //链表头部插入节点
    private void insertElemAtBeign(T data){
        SNode next = headNode.getNext();
        headNode.setNext(new SNode(data,next));
        length++;
    }

    //查找元素的前一个节点
    private SNode findPreNode(T data){
        SNode node = headNode;
        while (node.getNext() != null){
            if(data.equals(node.getNext().getElement())) {
                return node;
            }
            node = node.getNext();
        }
        return null;
    }

    //删除尾结点
    private void deleteElemAtEnd() {
        SNode ptr = headNode;

        if(ptr.getNext() == null){
            return;
        }

        while(ptr.getNext().getNext() != null){
            ptr = ptr.getNext();
        }

        SNode tmp = ptr.getNext();
        ptr.setNext(null);
        tmp = null;
        length --;
    }

    private void printAll(){
        SNode node = headNode.getNext();
        while (node != null){
            System.out.printf(node.getElement() + ",");
            node = node.getNext();
        }
        System.out.println();
    }

    public static class SNode<T> {
        private T element;

        private SNode next;

        public SNode(T element){
            this.element = element;
        }

        public SNode(T element,SNode next){
            this.element = element;
            this.next = next;
        }

        public SNode(){
            this.next = null;
        }

        public T getElement() {
            return element;
        }

        public void setElement(T element) {
            this.element = element;
        }

        public SNode getNext() {
            return next;
        }

        public void setNext(SNode next) {
            this.next = next;
        }
    }

    public static void main(String[] args) {
        LRUBaseLinkedList list = new LRUBaseLinkedList(5);
        Scanner sc = new Scanner(System.in);
        while (true) {
            list.add(sc.nextInt());
            list.printAll();
        }
    }
}