lru的简陋实现。。。。

这个是代码

package linked;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;

@SuppressWarnings("all")
public class MyLinked<T> {

    //如果accessOrder 为true 那么addfirst 就失效了  因为根据lru 他就应该排在后面
    private boolean accessOrder;

    private boolean accessNode;
    private Node head = null;
    private Node tail;
    private int count;

    public MyLinked() {
        head = new Node();
        tail = new Node();
        head.next = tail;
        tail.pre = head;
        count = 0;
        accessOrder = false;
    }

    public MyLinked(boolean accessOrder) {
        this();
        this.accessOrder = accessOrder;
    }

    void addFirst(T t) {
        Node node = new Node();
        node.setValue(t);
        Node next = head.getNext();
        node.setPre(head);
        node.setNext(next);
        next.setPre(node);
        head.setNext(node);
        count++;
        afterNodeAccess(t);
    }

    void addLast(T t) {
        add(t);
        afterNodeAccess(t);
    }

    void add(T t) {
        Node node = new Node();
        node.setValue(t);
        Node pre = tail.getPre();
        pre.setNext(node);
        node.setPre(pre);
        node.setNext(tail);
        tail.setPre(node);
        count++;
        afterNodeAccess(t);
    }


    T get(T t) {
        Node next = head.getNext();
        for (int i = 0; i < count; i++) {
            T value = (T) next.getValue();
            if (value.equals(t)){
                if (accessOrder){
                    Node next1 = next.getNext();
                    Node pre = next.getPre();
                    pre.setNext(next1);
                    next1.setPre(pre);
                    count--;
                    addLast(t);
                }
                return t;
            }

            next = next.getNext();
        }
        return null;
    }

    int indexOf(T t) {
        int cou = 0;

        Node next = head.getNext();
        for (int i = 0; i < count; i++) {
            T value = (T) next.getValue();
            cou++;
            if (value.equals(t))
                return cou;
            next = next.getNext();
        }
        return -1;

    }

    boolean remove(T t) {
        Node next = head.getNext();
        for (int i = 0; i < count; i++) {
            T value = (T) next.getValue();
            if (value.equals(t)) {
                Node pre = next.getPre();
                Node next1 = next.getNext();
                pre.setNext(next1);
                next1.setPre(pre);
                count--;
                return true;
            }
            next = next.getNext();
        }
        return false;

    }


    T pop() {
        Node next = head.getNext();
        Node next1 = next.getNext();
        head.setNext(next1);
        next1.setPre(head);
        count--;
        return (T) next.getValue();
    }

    int size() {
        return count;
    }


    List<T> getValue(int count) {
        checkSize(count);
        Node next = head.getNext();
        List<T> values = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            Object value = next.getValue();
            values.add((T) value);
            next = next.getNext();
        }
        return values;
    }

    private void checkSize(int size) {
        if (size > count)
            throw new IndexOutOfBoundsException("长度超过限制");
    }


    void afterNodeAccess(T t) {
        if (accessOrder) {
            //这里的第一次remove 是remove加进去的t 所以得remove2次   之前没考虑到
            boolean remove = remove(t);
            boolean remove2 = remove(t);
            accessOrder=false;
            addLast(t);
            if (!remove)
                count++;
            accessOrder=true;
        }

    }


    @Data
    class Node<T> {
        private Node pre;
        private Node next;
        private T value;

    }
}

这个是测试类

package linked;

import java.util.List;

/**
 * @DATE: 2020/7/15
 * @author: zhanghong
 **/
public class LinkMain {
    public static void main(String[] args) {

//        MyLinked<String> linked=new MyLinked(true);
        MyLinked<String> linked=new MyLinked(true);
        linked.add("1");
        linked.add("2");
        linked.addFirst("6");
        linked.addLast("9");
        linked.add("1");
//        linked.remove("2");
//        System.out.println("-----"+linked.pop());
//        System.out.println("-----"+linked.remove("1"));
        String s = linked.get("2");
//        System.out.println("----------"+s);
        List<String> value = linked.getValue(linked.size());
        value.forEach(v-> System.out.println(v));

      /*  System.out.println(linked.get());
        System.out.println(linked.get());
        System.out.println(linked.get());
        System.out.println(linked.get());
        System.out.println(linked.get());*/

    }
}

模仿lru算法 ，但是我感觉这个不好 因为这样每次在进行排序的时候就是一次遍历 太消耗性能

于是利用hashmap用来存储 node 中的value

做个标记 以后有时间再来实现

但是后来想想其实这方式还存在问题 因为我的lru 算法的话 加入存入2个一样的值实际上只能存入一个 ，感觉做法不妥当 ，想了想也许应该用双链表发吧 ，一个node也是一个链表 这样在存入第二个相同的元素的时候 就直接在第一个node 之后形成链表