自定义（单链表）集合类

类的结构

接口：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();


//    public boolean remove(Object o);


//    public Iterator<E> iterator();


//    public Object[] toArray();


//    public <T> T[] toArray(T[] a);


//    public boolean containsAll(Collection<?> c);
//
//
//    public boolean addAll(Collection<? extends E> c);
//
//
//    public boolean addAll(int index, Collection<? extends E> c) ;
//
//
//    public boolean removeAll(Collection<?> c);
//
//
//    public boolean retainAll(Collection<?> c);


//    public int lastIndexOf(Object o);
//
//
//    public ListIterator<E> listIterator();
//
//
//    public ListIterator<E> listIterator(int index);
//
//
//    public List<E> subList(int fromIndex, int toIndex);

}

抽象类：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;
    }
}

自定义（单链表）集合类：

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 static class Node<E>{
        E element;
        Node<E> next;
        Node(E element,Node<E> next){
            this.element = element;
            this.next = next;
        }
    }



    /**
     * 在指定索引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++;
    }


    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> oldNode;
        if (index==0) {
            oldNode = first;
            first = first.next;
            size--;
            return oldNode.element;
        }
        //先从一般的规律入手，写下来，再看特殊情况，
        //如果index=0，那么index-1就为负数，肯定是不行的，所以才有上面if (index==0) 的情况
        Node<E> pre = node(index - 1);
        oldNode = pre.next;
        pre.next = oldNode.next;
        size--;
        return oldNode.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;
        //通过x.next，循环遍历找到指定索引index对应的Node节点
        for (int i = 0; i < index; i++) {
            x = x.next;
        }
        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() {
        size = 0;
        first = null;
    }

    @Override
    public String toString() {
        if (size == 0) {
            return "[]";
        }
        StringBuilder sb= new StringBuilder();
        sb.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();
    }
}