List接口源码剖析

前言
觉得有必要好好的看看底层的一些东西，有些东西感觉理解的不是那么透彻，如果有什么错误，希望大家指正。

List结构图

接口之间的关系，绿色实线图表示继承。在我之前的博客已经说明，两个接口之间是不能用实现的，需要用继承。接口继承之后，在实现子接口的时候需要将父类的接口也实现。因此，需要从Iterable接口看起。
Iterable接口
去掉了多余注释

public interface Iterable<T> {
    Iterator<T> iterator();
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

从这里我们能够较为清晰的看到，Iterable接口主要的功能但是定义了遍历的方法。
Collection

public interface Collection<E> extends Iterable<E> {

    int size();//大小

    boolean isEmpty();//是否为空

    boolean contains(Object o);//是否存在类似于O的参数，常用于判断String中是否存在某个元素

    Iterator<E> iterator();//迭代器

    Object[] toArray();//变为数组

    <T> T[] toArray(T[] a);//将对象变为某种类型的数组

    boolean add(E e);//添加进入集合

    boolean remove(Object o);//移除某个元素

    boolean containsAll(Collection<?> c);//判断是否是子集
    boolean addAll(Collection<? extends E> c);//批量增加，往集合中添加集合
    boolean removeAll(Collection<?> c);//移除集合中存在的元素，eg：{1、2}，{2、3}={3}
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }
    boolean retainAll(Collection<?> c);				//移除不相等的元素
    void clear();									//移除所有元素
    boolean equals(Object o);						//是否内容相等
    int hashCode();//hash
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

显然，先从Iterable接口处继承来了遍历的方法，紧接着定义了接口必须拥有的方法，每个方法的功能已标注在代码中，其实常用的方法就是上面的方法。
List
他需要将前者继承过来，那么肯定拥有上面的所有功能，就会很庞大了。

public interface List<E> extends Collection<E> {
 
    int size();//list大小

    boolean isEmpty();//是否为空

    boolean contains(Object o);//是否拥有o

    Object[] toArray();//以每个对应下标为存储空间分割，然后转换为数组

    <T> T[] toArray(T[] a);//同上

    boolean add(E e);//添加进入List

    boolean remove(Object o);//移除o

    boolean containsAll(Collection<?> c);//c是否是子集

    boolean addAll(Collection<? extends E> c);//将c全部添加进入调用List

    boolean addAll(int index, Collection<? extends E> c);//交叉组成新的集合，{1、3}，{1、2}，index=1，result={1,1，3,2}

    boolean removeAll(Collection<?> c);//移除拥有相同的元素

    boolean retainAll(Collection<?> c);//移除不相等的元素

    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

    void clear();//移除所有元素

    boolean equals(Object o);//是否内容相等

    int hashCode();//hash

    E get(int index);//获取index处元素

    E set(int index, E element);//向集合中的index处添加元素

    void add(int index, E element);//无返回值的添加

    E remove(int index);//移除index处元素

    int indexOf(Object o);//返回o的初始位置

    int lastIndexOf(Object o);//返回o的最后位置

    ListIterator<E> listIterator();//list遍历器

    ListIterator<E> listIterator(int index);//从第几个开始遍历

    List<E> subList(int fromIndex, int toIndex);
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}

总结
感觉把所有的方法都了然之后才能快速的想到该用什么方法，这样在处理问题的时候能够有更多的想法。List接口是线性表的基础接口，对他熟悉了也就是对线性表的一些问题透彻了。对于@Override的方法还不是很清楚他的作用，也没有调用过，后面知道了再进行补充。

积土成山，风雨兴焉！！！