源码分析：

package java.util;

import java.util.function.UnaryOperator;

public interface List<E> extends Collection<E> { 
    /**
     * 定义size方法，应返回size大小，最大值为Integer.MAX_VALUE
     * @return
     */
    int size();

    /**
     * 定义isEmpty方法,用于返回是否为空
     * 如果不包含元素，则返回true
     * @return
     */
    boolean isEmpty();

    /**
     * 定义contains方法,判断一个obj是否属于此集合
     * 如不是集合，则返回true
     * @param o
     * @return
     */
    boolean contains(Object o);

    /**
     * 定义迭代器方法,返回一个迭代器对象
     * @return
     */
    Iterator<E> iterator();
    /**
     * 定义转换为转换Obj数组的方法,返回一个obj数组
     * @return
     */
    Object[] toArray();
    /**
     * 定义转换为泛型T数组的方法,返回一个指定泛型的数组
     * @param a
     * @param <T>
     * @return
     */
    <T> T[] toArray(T[] a);
    /**
     * 定义add方法,添加一个元素e,并返回添加成功标志
     * @param e
     * @return
     */
    boolean add(E e);
    /**
     * 定义remove方法,移除一个元素obj,并返回移除元素成功标志
     * @param o
     * @return
     */
    boolean remove(Object o);
    /**
     * 定义containsAll方法,判断是否包含集合实例对象c
     * @param c
     * @return
     */
    boolean containsAll(Collection<?> c);
    /**
     * 定义addAll方法,添加集合实例对象c到本实例中
     * @param c
     * @return
     */
    boolean addAll(Collection<? extends E> c);
    /**
     * 定义addAll方法，从某个index开始插入指定集合实例
     * @param index
     * @param c
     * @return
     */
    boolean addAll(int index, Collection<? extends E> c);
    /**
     * 定义removeAll方法,从本实例中移除集合实力对象c
     * @param c
     * @return
     */
    boolean removeAll(Collection<?> c);
    /**
     * 定义retainAll方法,取本例与集合实例c的交集,判断交集元素数量是否大于0
     * @param c
     * @return
     */
    boolean retainAll(Collection<?> c);

    /**
     * jdk1.8新增
     * 大意为：
     * 定义replaceAll方法，根据传递参数的函数式，传递内容是接口类型
     * 该接口定义了operator函数，该函数传递给Objects.requireNonNull进行判断
     * 匹配成功则进行set值进行替换，使用List迭代器进行迭代替换
     * @since 1.8
     */
    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }

    /**
     * 排序列表使用提供的 Comparator比较元素。
     * @param c
     */
    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);
        }
    }

    /**
     * 定义clear方法,清除本例集合中的所有元素
     */
    void clear();
    /**
     * 定义equals方法,判断对象是否相对
     * @param o
     * @return
     */
    boolean equals(Object o);
    /**
     * 定义hashCode方法,获取hashCode标记的方法
     * @return
     */
    int hashCode();


    /**
     * List要求，定义get方法，获取指定index的值
     * @param index
     * @return
     */
    E get(int index);

    /**
     * List要求，定义set方法，在指定index的元素设置为目标元素
     * @param index
     * @param element
     * @return 修改前的元素
     */
    E set(int index, E element);

    /**
     * 在指定位置插入指定元素在这个列表(可选操作)。变化的元素目前位置(如果有的话)和任何后续元素向右(添加一个索引)。
     * @param index 指数要插入指定的元素
     * @param element 元素被插入
     */
    void add(int index, E element);

    /**
     * 这个列表中删除指定位置的元素(可选操作)。任何后续元素转移到左(减去一个来自他们的指标)。返回的元素从列表中删除。
     * @param index 删除元素的索引
     * @return
     */
    E remove(int index);


    /**
     *
     * 获取查询元素的index,若备查元素为null,则寻找空元素,返回index
     * 若备查元素不为null，则使用equal判断该元素是否存在，并返回index
     * 不存在则返回-1
     * 被contains调用
     * @param o
     * @return
     */
    int indexOf(Object o);

    /**
     * 倒叙查询第一个出现的被查元素
     * @param o 元素搜索
     * @return
     */
    int lastIndexOf(Object o);


    /**
     * 返回一个列表迭代器在这个列表的元素(在适当的序列)
     * @return
     */
    ListIterator<E> listIterator();

    /**
     * 返回一个列表迭代器在这个列表的元素(在适当的序列),开始在指定的位置在列表中。指定的索引显示返回的第一个元素,一个初始调用 next。初始调用 previous将返回指定索引的元素- 1。
     * @param index 索引返回第一个元素的列表迭代器(通过调用 next)
     * @return
     */
    ListIterator<E> listIterator(int index);


    /**
     *返回一个指定的部分之间的这个列表视图 fromIndex,包容,和 toIndex,排斥。(如果 fromIndex和 toIndex是相等的,返回的列表是空的。)
     * @param fromIndex 低端点(包容)的子列表
     * @param toIndex 高端点(独家)的子列表
     * @return 在这个列表的视图指定范围
     */
    List<E> subList(int fromIndex, int toIndex);

    /**
     * Creates a {@link Spliterator} over the elements in this list.
     *
     * <p>The {@code Spliterator} reports {@link Spliterator#SIZED} and
     * {@link Spliterator#ORDERED}.  Implementations should document the
     * reporting of additional characteristic values.
     *
     * @implSpec
     * The default implementation creates a
     * <em><a href="Spliterator.html#binding">late-binding</a></em> spliterator
     * from the list's {@code Iterator}.  The spliterator inherits the
     * <em>fail-fast</em> properties of the list's iterator.
     *
     * @implNote
     * The created {@code Spliterator} additionally reports
     * {@link Spliterator#SUBSIZED}.
     *
     * @return a {@code Spliterator} over the elements in this list
     * @since 1.8
     */
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}