基于双向链表实现的LRU算法，支持泛型

先一篇泛型总结得很好的博客：https://segmentfault.com/a/1190000014120746

用双向链表实现LRU，要求可以指定缓存大小，并且可以存储任意类型的数据。
        (要求用泛型，只需要实现添加方法即可)。
分析：
1.LRU实现
    操作：
    添加：是否存在？存在-删除-添加到表头； 不存在-看表长？删除末尾添加到表头 or 直接添加到表头
    删除：查找，存在-删除
    数据结构：带表头双链表

2.任意类型数据-泛型实现

package day3practice;


public class GenericParadigm {
    public static void main(String args[]){
        ListLRUGenne<Integer> lru = new ListLRUGenne<>(6,new NodeGenne());
        lru.addNodeLRU(5);
        lru.addNodeLRU(4);
        lru.addNodeLRU(3);
        lru.addNodeLRU(2);
        lru.addNodeLRU(1);
        lru.printLRU();
        lru.addNodeLRU(6);
        lru.printLRU();
        lru.addNodeLRU(3);
        lru.printLRU();
        lru.addNodeLRU(7);
        lru.printLRU();
       //
        ListLRUGenne<String> lru2 = new ListLRUGenne<>(6,new NodeGenne());
        lru2.addNodeLRU("一护");
        lru2.addNodeLRU("鸣人");
        lru2.addNodeLRU("路飞");
        lru2.addNodeLRU("奇伢");
        lru2.addNodeLRU("爱德华");
        lru2.printLRU();
        lru2.addNodeLRU("兵长");
        lru2.printLRU();
        lru2.addNodeLRU("奇伢");
        lru2.printLRU();
        lru2.addNodeLRU("柯南");
        lru2.printLRU();


}
}

package day3practice;


public class ListLRUGenne<T> { //带头结点的单链表，根据题意，所有结点值不同
    static int lenLimit;
    static NodeGenne headNode = new NodeGenne();
    public ListLRUGenne(int lenLimit,NodeGenne headNode){
        this.lenLimit = lenLimit;
        this.headNode = headNode;
    }

    static public int length(){
        int length = 0;
        NodeGenne scan = headNode;
        while(scan.next!=null){
            scan=scan.next;
            length++;

        }
        return  length;
    }

    //LRU算法的添加的逻辑：
    public void addNodeLRU(T value){
        NodeGenne newone = new NodeGenne(value);//先创建一个待加入的新结点
        NodeGenne p = headNode;//p是扫描指针

        while(p.value != newone.value&&p.next!=null){
            p=p.next;
        }
        //出循环两种可能，遍历结束没有找到，或者是找到了
        if(p.next == null){//遍历完了没有找到
            int len= ListLRUGenne.length();
            if(len<lenLimit){ //不需要删除操作，直接在头部添加
               addNode(headNode,newone);

            }else{
                //先删除最后一个结点
                deleteNode(p);
                //再在列表头部添加
                addNode(headNode,newone);

            }
        }else{ //找到了这个结点，删除，在头部添加
            deleteNode(p);
            addNode(headNode,newone);
        }
    }

    public void deleteNode(NodeGenne p){
        if(p.next == null){
            p.pre.next = null; //删除的是尾结点
        }
        else{//删除的是中间结点
            p.pre.next = p.next;
            p.next.pre = p.pre;
        }
    }

//双链表添加结点
    public void addNode(NodeGenne p,NodeGenne newone){
        if(p.next == null){ //末尾添加
            p.next = newone;
            newone.pre = p;
        }else{ // 中间添加
            newone.next = p.next;
            newone.pre = p;
            p.next.pre = newone;
            p.next = newone;
        }

    }

    public void printLRU(){
        NodeGenne p = headNode;
        if(p.next == null) System.out.println("LRU链表当前无结点");
        while(p.next!= null){
            p = p.next;
            System.out.print(p.value+"  ");
        }
        System.out.println();
    }
}

package day3practice;

public class NodeGenne <T>{
    T value;
    NodeGenne next=null;
    NodeGenne pre = null;

    public NodeGenne(T value, NodeGenne next,NodeGenne pre){
        this.value = value;
        this.next = next;
        this.pre = pre;
    }
    public NodeGenne(T value){
        this.value = value;
    }
    public NodeGenne(){
    }

}

//用双向链表实现LRU，要求可以指定缓存大小，并且可以存储任意类型的数据。
//       (要求用泛型，只需要实现添加方法即可)。
//分析：
/*1.LRU实现
    操作：
    添加：是否存在？存在-删除-添加到表头； 不存在-看表长？删除末尾添加到表头 or 直接添加到表头
    删除：查找，存在-删除
    数据结构：带表头双链表

2.任意类型数据-泛型实现
 */