自定义（双链表）集合类

包结构

MyList 接口 

package day2_19.inter;

/**
 * 将arryList 和 linkedList 共性的方法进行抽取 --->保证体系的完整性
 *
 * @Author Tianhao
 * @create 2021-02-19-17:26
 */

public interface MyList<E>{


    public int size();

    public boolean isEmpty();
    
    public boolean contains(Object o);

    public boolean add(E e);

    public void add(int index, E element);

    public E remove(int index);

    public E get(int index);
    
    public E set(int index, E element);
    
    public int indexOf(Object o);

    public void clear();

    String toString();

}

MyAbstractList 抽象类

package day2_19.abstractClass;

import day2_19.inter.MyList;

/**
 *
 * 用于实现arryList 和 linkedList中那些相同的方法
 *
 * @Author Tianhao
 * @create 2021-02-19-17:46
 */

public abstract class MyAbstractList<E> implements MyList<E> {
    protected int size;

    /**
     * 获取元素个数
     * @return 元素个数
     */
    @Override
    public int size() {
        return size;
    }

    /**
     * 判断集合是否为空
     * @return
     */
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 判断集合是否包含指定元素
     * indexOf(Object o):寻找对应的元素，如果找到了返回元素的索引，如果没有找到返回 -1
     * @param o
     * @return
     */
    @Override
    public boolean contains(Object o) {
        return indexOf(o) != -1;
    }


    /**
     * 在集合的最后添加一个元素，也就是在索引为size处添加一个元素
     * @param e
     * @return
     */
    @Override
    public boolean add(E e) {
        add(size,e);
        return true;
    }
}

MyLinkedList 类

package day2_19.linked;

import day2_19.abstractClass.MyAbstractList;

/**
 *
 * 自定义（单链表）集合类
 *
 * @Author Tianhao
 * @create 2021-02-19-18:01
 */
public class MyLinkedList<E> extends MyAbstractList<E> {

    private Node<E> first;
    private Node<E> last;

    private static class Node<E>{
        E element;
        Node<E> next;
        Node<E> pre;
        Node(Node<E> pre,E element,Node<E> next){
            this.element = element;
            this.next = next;
            this.pre = pre;
        }
    }



    /**
     * 在指定索引index处插入指定元素
     * @param index 注意：index >= 0 && index <= size （是可以插入到最后一个元素的下一个位置的）
     * @param element
     */
    @Override
    public void add(int index, E element) {
        checkPositionIndex(index);//判断index >=0 && index <= size

        //方法一：常规思维
//        if (index == 0) {//这里不管first是否为null,都是没有问题的
//            //如果最开始的first为null,则插入的节点为node(element,null)，被first指向
//            //如果最开始的first不为null，则插入的节点为node(element,first),除了被first指向，它还指向最开始的那个first
//            first = new Node(element, first);
//        } else {//插入位置索引不是0
//            Node<E> pre = node(index - 1);//前一个节点
//            Node<E> next = pre.next;//后一个节点
//            pre.next = new Node(element,next);//前一个节点指向插入的节点，这个插入的节点指向后一个节点
//        }
//        size++;

        //方法二：代码简化
        //思路：获得指定的index的节点 2.前一个节点的获取 3.构建要插入的节点 4.改变1和2的指向
        if (index == size) {//涉及到last，包含两种情况：1.原来有元素的时候，新元素添加到末尾  2.原来没有元素的时候
            linkLast(element);
        } else {//不涉及到last
            linkBefore(element,index);
        }
        size++;



    }

    private void linkLast(E element) {
        //方法一：常规思维
//        Node newNode;
//        if (size == 0) {//原来没有元素的时候
//            //1.构建要插入的节点newNode,完成它的指向关系
//            newNode = new Node(null, element, null);
//            //2.first指向新节点
//            first = newNode;
//        } else {//原来有元素的时候，新元素添加到末尾
//            //1.拿到原来的最后一个节点
//            Node<E> pre = last;
//            //2.构建要插入的节点newNode,完成它的指向关系
//            newNode = new Node(pre, element, null);
//            //3.将原来的最后一个节点指向新节点
//            pre.next = newNode;
//        }
//        //最后将last指向新节点
//        last = newNode;

        //方法二：代码简化
        Node newNode;
        //1.拿到last
        Node<E> pre = last;
        //2.构建要插入的节点newNode,完成它的指向关系
        newNode = new Node(pre, element, null);
        //3.将last指向新节点
        last = newNode;
        if (pre == null) {//原来没有元素的时候
            //first指向新节点
            first = newNode;
        } else {//原来有元素的时候，新元素添加到末尾
            //将原来的最后一个节点指向新节点
            pre.next = newNode;
        }


    }

    private void linkBefore(E element,int index) {
        //1.获取索引index处的节点
        Node<E> next = node(index);
        //2.获取索引(index-1)处的节点
        Node<E> pre = next.pre;
        //3.构建要插入的节点newNode,完成它的指向关系
        Node<E> newNode = new Node(pre, element, next);
        //4.索引index处的节点指向新节点
        next.pre = newNode;

        if (pre == null) { //索引index==0时
            //first指向新节点
            first = newNode;
        } else {
            //索引(index-1)处的节点指向新节点
            pre.next = newNode; //为了防止此行空指针异常，所以必须考虑pre === null的情况
        }
    }


    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index)) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
    }

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= size;
    }

    /**
     * 移除集合中指定索引的元素，并返回这个元素
     * @param index
     * @return
     */
    @Override
    public E remove(int index) {
        checkElementIndex(index);
        //先从一般的规律入手，写下来，再看特殊情况，
        Node<E> node = node(index);
        final E element = node.element;
        final Node<E> pre = node.pre;
        final Node<E> next = node.next;
        if (pre == null) { //index == 0
            first = next;
        } else {
            pre.next = next;
            //将要移除节点的pre设置为null
            node.pre = null;
        }
        if (next == null) {
            last = pre;

        } else {
            next.pre = pre;
            //将要移除节点的next设置为null
            node.next = null;
        }
        //将要移除节点的element设置为null
        node.element = null;
        size--;
        return element;
    }



    /**
     * 获取指定索引（节点）处的元素
     * 因为增删改都是基于先找到元素，所以这个方法最先实现比较好
     * @param index
     * @return
     */
    @Override
    public E get(int index) {
        checkElementIndex(index);
        return node(index).element;

    }

    /**
     * 检查指定索引，如果集合中不存在这个指定索引，则抛出异常
     * @param index
     */
    private void checkElementIndex(int index) {
        if (!isElementIndex(index)) {
            throw new IndexOutOfBoundsException("Index: " + index + ",Size: " + size);
        }
    }

    /**
     * 找到指定索引index对应的Node节点
     * @param index
     * @return
     */
    private Node<E> node(int index) {
        //获取集合第一个元素first
        Node<E> x = first;
        //先去判断要查找的index是靠近头还是靠近尾，如果靠近头，从头开始找；如果靠近尾，从尾开始找
        //如果index小于size的二分之一，则靠近头
        //size>>1:向右移动一位，就除以2
        if (index < (size >> 1)) {
            for (int i = 0; i < index; i++) {
                x = x.next;
            }
        } else {
            x = last;
            for (int i = size-1; i > index; i--) {
                x = x.pre;
            }
        }

        return x;
    }

    /**
     * 判断集合中是否存在指定索引
     * @param index
     * @return
     */
    private boolean isElementIndex(int index) {
        return index >= 0 && index < size;
    }


    /**
     * 将指定索引处的元素替换为指定的元素
     * @param index 指定的索引
     * @param element 将要替换到指定索引处的元素
     * @return 返回指定索引处被替换的元素
     */
    @Override
    public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> node = node(index);
        E oldEle = node.element;
        node.element = element;
        return oldEle;
    }

    /**
     * 查找第一次出现指定元素o的索引位置
     * @param o
     * @return 如果有,返回o在集合中的索引;如果没有,返回-1
     */
    @Override
    public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
            //多去理解这种遍历思维
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.element == o) {
                    return index;
                }
                //还有这种返回索引的思维也要多学习
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.element)) {
                    return index;
                }
                index++;
            }
        }
        return -1;
    }

    /**
     * 清空集合的所有元素
     *
     * 可达性算法：判断对象是否是一个垃圾的标准
     *  选取一个节点，作为GC ROOTS顶点，其他对象或者引用去指向这个GC ROOTS顶点，如果这些对象
     *  能够到达这个GC ROOTS顶点，那么这些对象不是垃圾，反之就是。
     *
     */
    @Override
    public void clear() {
        //遍历所有的节点，只要不为null，就将其pre,next,element都设置为null
        for (Node<E> x = first; x != null;) {
            Node<E> next = x.next;
            x.pre = null;
            x.next = null;
            x.element = null;
            x = next;
        }
        size = 0;
        first = null;
        last = null;
    }

    @Override
    public String toString() {
        if (size == 0) {
            return "[]";
        }
        StringBuilder sb= new StringBuilder().append('[');
        for( Node<E> x = first;x!=null;x=x.next){
            sb.append(x.element);
            if (x.next == null) {
                return sb.append(']').toString();
            }
            sb.append(',').append(' ');
        }
        return sb.toString();
    }
}