Java List 接口

List 接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引来访问 List 中的元素，第一个元素的索引为 0，而且允许有相同的元素。

源码展示

package java.util;

import java.util.function.UnaryOperator;

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

    /**
     * 返回 list 中元素的个数。
     */
    int size();

    /**
     * list 是否为空。
     */
    boolean isEmpty();

    /**
     * list 是否包含某个对象。
     */
    boolean contains(Object o);

    /**
     * 返回一个正确顺序的迭代器。
     */
    Iterator<E> iterator();

    /**
     * 返回一个包含所有元素的有序数组。
     */
    Object[] toArray();

    /**
     * 返回一个包含所有元素的有序泛型数组。
     */
    <T> T[] toArray(T[] a);

    /**
     * 添加一个元素到这个 list 的结尾。
     */
    boolean add(E e);

    /**
     * 删除第一个出现在 list 中的对象。
     */
    boolean remove(Object o);

    /**
     * list 是否包含所有集合元素。
     */
    boolean containsAll(Collection<?> c);

    /**
     * 添加集合中的元素到 list 中。
     */
    boolean addAll(Collection<? extends E> c);

    /**
     * 添加集合中的元素到 list 指定位置中。
     */
    boolean addAll(int index, Collection<? extends E> c);

    /**
     * 删除 list 中的所用给定的元素。
     */
    boolean removeAll(Collection<?> c);

    /**
     * 保留 list 中含有给定的元素。
     */
    boolean retainAll(Collection<?> c);

    /**
     * 应用 operator 得到元素的结果替换 list 的元素。
     */
    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 来排序。
     */
    @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);
        }
    }

    /**
     * 清空 list 中的所有数据。
     */
    void clear();

    /**
     * 比较是否相等。
     */
    boolean equals(Object o);

    /**
     * 返回 list 的 hashcode。
     */
    int hashCode();

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

    /**
     * 在指定位置，替换指定元素。
     */
    E set(int index, E element);

    /**
     * 在指定位置，插入指定元素。
     */
    void add(int index, E element);

    /**
     * 移除指定位置的元素。
     */
    E remove(int index);

    /**
     * list 中元素第一次出现的位置。
     */
    int indexOf(Object o);

    /**
     * list 中元素最后一次出现的位置。
     */
    int lastIndexOf(Object o);

    /**
     * 返回 list 独有迭代器。
     */
    ListIterator<E> listIterator();

    /**
     * 返回 list 指定位置以后元素的迭代器。
     */
    ListIterator<E> listIterator(int index);

    /**
     * 根据开始和结束坐标返回子 list 的视图。
     */
    List<E> subList(int fromIndex, int toIndex);

    /**
     * 创建一个 Spliterator。
     */
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}