public interface List extends Collection

package java.util;

import java.util.function.UnaryOperator;

public interface List<E> extends Collection<E> {
    // 查询操作

    /**
     * 数组大小
     */
    int size();

    boolean isEmpty();

    boolean contains(Object o);

    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 addAll(int index, Collection<? extends E> c);

    boolean removeAll(Collection<?> c);

    boolean retainAll(Collection<?> c);

    /**
     * 替换元素
     * @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()));
        }
    }

    /**
     * 根据指定的比较器进行排序
     * @since 1.8
     */
    @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();


    // 比较和hashing

    boolean equals(Object o);

    int hashCode();


    // 位置访问操作

    /**
     * 返回此列表中指定位置的元素。
     */
    E get(int index);

    /**
     * 将此列表中指定位置的元素替换为指定的元素 (可选操作)。
     */
    E set(int index, E element);

    void add(int index, E element);

    E remove(int index);


    // 搜索操作

    /**
     * 返回此列表中指定元素的第一个匹配项的索引, 如果此列表不包含元素, 则为-1.
     */
    int indexOf(Object o);

    /**
     * 返回此列表中指定元素的最后一个匹配项的索引, 如果此列表不包含元素, 则为-1。
     */
    int lastIndexOf(Object o);


    // 列表迭代器

    /**
     * 返回列表迭代器 (按正确顺序)。
     */
    ListIterator<E> listIterator();

    /**
     * 返回列表迭代器 (按正确顺序)。
     */
    ListIterator<E> listIterator(int index);

    // 展示

    /**
     * 返回此列表中指定范围的列表元素
     */
    List<E> subList(int fromIndex, int toIndex);

    /**
     * 并行遍历
     */
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}
package java.util;

import java.util.functi