单向链表

相比于链表，动态数组有一个很大的缺点，就是会造成很大的空间浪费；
链表则可以做到用多少就申请多少内存；

链表：是一种链式存储的线性表，所有元素的内存地址不一定是连续的。

链表的结构-摘自小码哥课件

对于链表，由一个个节点元素Node元素组成，其first指针指向链表的第一个元素；size表示有多少个节点；

Node节点：

element：存放的是泛型对象
next：指向下一个节点元素的指针

1.接口设计

在动态数组和链表的实现方法中，所有的接口都是可以共用的，所以可以创建一个Interface，将所有公共的接口放到这个文件中；
有部分例如siz(), isEmpty()等接口，可以抽象出一个类，使得ArrayList和LinkedList都继承自这个类；

interface ：

public interface List <E> {

    static final int ELEMENT_NOT_FOUND = -1;
    /**
     * 清除所有元素
     */
    void clear();

    /**
     * 元素的数量
     * @return
     */
    int size();

    /**
     * 是否为空
     * @return
     */
    boolean isEmpty();

    /**
     * 是否包含某个元素
     * @param element
     * @return
     */
    boolean contains(E element);

    /**
     * 添加元素到尾部
     * @param element
     */
    void add(E element);

    /**
     * 获取index位置的元素
     * @param index
     * @return
     */
    E get(int index);

    /**
     * 设置index位置的元素
     * @param index
     * @param element
     * @return 原来的元素ֵ
     */
    E set(int index, E element);

    /**
     * 在index位置插入一个元素
     * @param index
     * @param element
     */
    void add(int index, E element);

    /**
     * 删除index位置的元素
     * @param index
     * @return
     */
    E remove(int index);

    /**
     * 查看元素的索引
     * @param element
     * @return
     */
    int indexOf(E element);
}

公共抽象类：AbstractList

//abstract 修饰以后可以不实现interface中的接口，或者部分实现
public abstract class AbstractList<E> implements List<E>{
    protected int size;

    /** 
     * 元素的数量
     * **/
    public int size(){
        return size;
    }
    
    /*
     * 判断是否为空
     * **/
    public boolean isEmpty() {
        return size == 0;
    }
    
    /*
     * 是否包含某个元素E
     * **/
    public boolean contains(E element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }
    
    /*
     *  添加元素到末尾
     **/
    public void add(E element) {
        add(size,element);
    }
    
    /*
     * 范围检查
     * */
    protected void rangeCheck(int index){
        if (index < 0 || index >= size) {
            throwException(index);
        }
    }
    /*
     * 添加元素范围检查
     * */
    protected void rangeCheckforAdd(int index){
        if (index < 0 || index > size) {
            throwException(index);
        }
    }
    /*
     * 抛出异常
     * */
    protected void throwException(int index){
        throw new IndexOutOfBoundsException("Index" + index + ",Size"+ size);
    }
}

注意细节：

允许在子类中使用：protected 关键字修饰；
实现interface中接口方法： implements List<E>；
部分实现interface中接口方法：使用abstract关键字修饰；
在ArrayList及LinkedList中继承自AbstractList：extends AbstractList <E>

2.具体方法实现

1 、获取index位置的节点：

 /**获取index位置的节点
   * */
  private Node<E> node(int index){
      rangeCheck(index);
      Node<E> node = first;
      for (int i = 0; i < index; i++) {
          node = node.next;
      }
      return node;
  }

for循环遍历index次，获得第index位置的节点；

2、清空链表 clear()

  public void clear() {
      size = 0;
      first = null;
  }

首先size = 0，其次将first指针指向null，则后面所有的元素被指向的指针都会消失，则链表会被清空；

3、获取指定位置元素get(int index)

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

4、设置指定位置元素set(int index, E element)

  public E set(int index, E element) {
      Node<E> node = node(index);
      E old = node.element;
      node.element = element;
      return old;
  }

获取当前index的元素，替换其值element

5、获取指定位置元素add(int index, E element)

  public void add(int index, E element) {
      if (index == 0) {
          first = new Node<>(element, first);
      }else{
          Node<E> prev = node(index - 1);
          prev.next = new Node<>(element,prev.next);
      }
      size++;
  }

当index ==0 时，创建一个新的Node节点，其next指针指向原有的第一个位置的元素，即first.next;
当index > 0 时；先获取前一个节点，前一个节点指向新创建的节点，新创建的节点的next指向prev.next；

6、删除指定位置元素remove(int index)

  public E remove(int index) {
      Node<E> node = first;
      if (index == 0) {
          first = first.next;
      }else{
          Node<E> prev = node(index - 1);
          node = prev.next;
          prev.next = prev.next.next;
      }
      size --;
      return node.element;
  }

当index ==0 时，直接将first指针指向第一个节点first.next;
当index > 0 时；先获取前一个节点，前一个节点指index - 1位置的元素prev.next.next；

7、获取指定位置元素的索引indexOf(E element)

  public int indexOf(E element) {
      Node<E> node = first;
      if (element == null) {
          for (int i = 0; i < size; i++) {
              if(node.element==null) return i;
              node = node.next;
          }
      }else{
          for (int i = 0; i < size; i++) {
              if(element.equals(node.element)) return i;
              node = node.next;
          }   
      }
      return ELEMENT_NOT_FOUND;
  }

当element == null 时，直接for循环返回node.element == null对应的i;
当element != null 时；直接for循环返回node.element == element对应的i；