数据结构--链表实际场景应用

实践应用场景，构造一个固定长度的列表，达到固定长度后，自动淘汰尾部的节点

    /**
     * 固定大小的容器，当添加的个数达到上限时，
     * 自动淘汰添加时间最长的元素
     *
     * @param <E>
     */
    private static class FixElementList<E> {

        /**
         * 头指针
         */
        private Node<E> head;

        /**
         * 尾指针
         */
        private Node<E> tail;

        /**
         * 容积
         */
        private Integer capacity;

        /**
         * 容器节点数
         */
        private int size;

        public FixElementList(int capacity) {
            this.capacity = capacity;
        }

        public E add(E e) {
            size++;
            Node<E> node = new Node<>(e);
            node.next = head;
            if (head != null) {
                head.before = node;
            } else {
                //初始化，那么尾指针指向当前节点
                tail = node;
            }
            head = node;

            if (size > capacity) {
                size--;
                //开始淘汰
                Node<E> lastNode = tail;
                Node<E> lastThirdNode = tail.before;
                lastThirdNode.next = null;
                tail.before = null;
                tail = lastThirdNode;
                return lastNode.e;
            } else {
                return null;
            }
        }

        private static class Node<E> {

            private E e;

            /**
             * 后指针
             */
            private Node<E> next;

            /**
             * 前指针
             */
            private Node<E> before;

            Node(E e) {
                this.e = e;
            }
        }
    }

测试代码：

    @Test
    public void test04() {
        FixElementList<Integer> lruMap = new FixElementList<>(4);
        for (int i = 1; i <= 10; i++) {
            Integer addResult = lruMap.add(i);
            if (addResult != null) {
                System.out.println("淘汰的value：" + addResult);
            }
        }
    }