参考LinkedList，手写双向链表

package transferlinked;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

/**
 * 双向链表
 * <p>
 * Version    1.0.0
 *
 * @author zhouyuyou
 * <p>
 * Date          2020/05/06 17:07
 */
public class BothwayLinkedList<E> {

    /**
     * 头节点
     */
    private Node<E> head;
    /**
     * 尾节点
     */
    private Node<E> tail;
    /**
     * 长度
     */
    private transient int size = 0;
    /**
     * 关键字transient 标识的字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。
     * 修改次数
     */
    private transient int modCount = 0;

    private static class Node<E>{
        E item;
        Node<E> prev;
        Node<E> next;

        public Node(E item, Node<E> prev, Node<E> next) {
            this.item = item;
            this.prev = prev;
            this.next = next;
        }
    }

    /***
     * 尾部插入
     * @param e
     */
    public boolean add(E e){
        addLast(e);
        return true;
    }

    public void add(int index,E e){
        //校验参数
        //如果是添加到末尾
        if(index == size){
            addLast(e);
        }else {
            // 找到该索引的元素
            Node<E> node = node(index);
            addBefore(e,node);
        }
    }

    public E get(int index){
       return node(index).item;
    }

    public E remove(int index){
        Node<E> node = node(index);
       return unlink(node);
    }

    E unlink(Node<E> node){
        E item = node.item;
        Node<E> prev = node.prev;
        Node<E> next = node.next;
        //头节点
        if(null == prev){
            head = next;
        }else{
            prev.next = next;
            node.prev = null;
        }
        if(null == node.next){
            tail = prev;
        }else  {
            next.prev = prev;
            node.next = null;
        }
        node.item = null;
        size--;
        modCount++;
        return item;
    }

    Node<E> node(int index){
        //判断是从头节点遍历还是尾节点
        if(index < (size >> 1)){
            Node<E> x = head;
            for(int i = 0;i < index;i++ ){
                x = x.next;
            }
            return x;
        }else {
            Node<E> x = tail;
            for(int i = size - 1;i > index;i--){
                x = x.prev;
            }
            return x;
        }
    }

    void addBefore(E e,Node<E> node){
        Node<E> prev = node.prev;
        Node<E> newNode = new Node<>(e,prev,node);
        if(null == prev){
            head = newNode;
        }else {
            prev.next = newNode;
        }
        node.prev = newNode;
        size++;
        modCount++;
    }
    void addLast(E e){
        final Node<E> l = tail;
        final Node<E> newNode = new Node<>(e,l,null);
        //将加入的新节点作为尾节点
        tail = newNode;
        if(head == null){
            //说明第一次加入
            head = newNode;
        }else {
            l.next = newNode;
        }
        size++;
        modCount++;
    }

    private E unlinkFirst(){
        Node<E> f = head;
        E item = f.item;
        Node<E> next = f.next;
        f.item = null;
        f.next = null;
        head = next;
        //说明只有一个节点
        if(null == next){
            //将尾结点设为null
            tail = null;
        }else {
            next.prev = null;
        }
        size--;
        modCount++;
        return item;
    }

    private E unlinkLast(){
        Node<E> f = tail;
        E item = f.item;
        Node<E> prev = f.prev;
        f.item = null;
        f.prev = null;
        tail = prev;
        //说明只有一个节点
        if(null == prev){
            //将头结点设为null
            head = null;
        }else {
            prev.next = null;
        }
        size--;
        modCount++;
        return item;
    }

    public ListIterator<E> listIterator(int index) {
        return new LinkedIterator(index);
    }

    private class LinkedIterator implements ListIterator<E>{

        private Node<E> lastReturned;
        private Node<E> next;
        private int nextIndex;
        private int expectedModCount = modCount;

        public LinkedIterator(int index) {
            next = (index == size)? null : node(index);
            this.nextIndex = index;
        }

        @Override
        public boolean hasNext() {
            return nextIndex < size;
        }

        @Override
        public E next() {
            //check 是否有并发修改
            //check 是否有下一个元素
            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }

        @Override
        public boolean hasPrevious() {
            return nextIndex > 0;
        }

        @Override
        public E previous() {
            //check 是否有并发修改
            //check 是否有上一个元素
            lastReturned = next = (next == null)? tail : next.prev;
            nextIndex--;
            return lastReturned.item;
        }

        @Override
        public int nextIndex() {
            return nextIndex;
        }

        @Override
        public int previousIndex() {
            return nextIndex - 1;
        }

        @Override
        public void remove() {
            //check 并发修改、最后查询的节点不能为空
            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if(next == lastReturned){
                next = lastNext;
            }else {
                nextIndex--;
            }
            lastReturned = null;
            expectedModCount++;
        }

        @Override
        public void set(E e) {

        }

        @Override
        public void add(E e) {

        }
    }

    public static void main(String[] args) {
        BothwayLinkedList<Integer> linkedList = new BothwayLinkedList<>();
        linkedList.add(11);
        linkedList.add(22);
        linkedList.add(1,2222222);
        linkedList.add(33333);
        linkedList.add(4444);
        linkedList.remove(3);
        System.out.println(linkedList.get(3));
//        ListIterator<Integer> integerListIterator = linkedList.listIterator(0);
//        while (integerListIterator.hasNext()){
//            Integer next = integerListIterator.next();
//            if(22==next){
//                integerListIterator.remove();
//                continue;
//            }
//            System.out.println(next);
//        }
//        System.out.println(linkedList.size);
    }
}