模块 java.base
包 java.util

接口 List<E>

类型参数：
E - 此list中元素的类型
所有父级接口：
Collection<E> , Iterable<E>
所有已知的实现类：
AbstractList , AbstractSequentialList , ArrayList , AttributeList , CopyOnWriteArrayList , LinkedList , RoleList , RoleUnresolvedList , Stack , Vector
public interface List<E> extends Collection <E>
有序集合（也称为顺序).该界面的用户可以精确控制每个元素在列表中的插入位置。用户可以通过整数索引（在列表中的位置）访问元素，并在列表中搜索元素。

与集合不同，列表通常允许重复元素。更正式地说，列表通常允许成对的元素 e1 和 e2 这样 e1.equals(e2) ，并且如果它们完全允许空元素，它们通常允许多个空元素。可以想象有人可能希望通过在用户尝试插入时抛出运行时异常来实现禁止重复的列表，但我们希望这种用法很少见。

List 接口在 iterator 、 add 、 remove 、 equals 和 hashCode 方法的约定中放置了额外的规定，超出了 Collection 接口中指定的规定。为方便起见，此处还包含其他继承方法的声明。

List 接口提供了四种用于对列表元素进行位置（索引）访问的方法。列表（如 Java 数组）是从零开始的。请注意，对于某些实现（例如 LinkedList 类），这些操作的执行时间可能与索引值成正比。因此，如果调用者不知道实现，则迭代列表中的元素通常比通过它进行索引更可取。

List 接口提供了一个特殊的迭代器，称为 ListIterator ，除了 Iterator 接口提供的正常操作之外，它还允许元素插入和替换以及双向访问。提供了一种方法来获取从列表中的指定位置开始的列表迭代器。

List接口提供了两种搜索指定对象的方法。从性能的角度来看，应谨慎使用这些方法。在许多实现中，它们将执行代价高昂的线性搜索。

List 接口提供了两种方法来高效地在列表中的任意点插入和删除多个元素。

注意：虽然允许列表将自身包含为元素，但建议格外小心：equals 和 hashCode 方法不再在此类列表中明确定义。

一些列表实现对它们可能包含的元素有限制。例如，有些实现禁止空元素，有些实现对其元素的类型有限制。尝试添加不合格的元素会引发未经检查的异常，通常是 NullPointerException 或 ClassCastException 。尝试查询不合格元素的存在可能会抛出异常，或者可能只是返回 false；有些实现会表现出前者的行为，有些会表现出后者。更一般地，尝试对不合格元素执行操作，其完成不会导致将不合格元素插入列表中可能会抛出异常，也可能会成功，具体取决于实现的选择。此类异常在该接口的规范中被标记为“可选”。

不可修改的列表

List.of 和 List.copyOf 静态工厂方法提供了一种创建不可修改列表的便捷方法。通过这些方法创建的List实例具有以下特征：

  • 他们是不可修改的。不能添加、删除或替换元素。调用 List 上的任何 mutator 方法将始终导致抛出 UnsupportedOperationException。但是，如果包含的元素本身是可变的，这可能会导致 List 的内容看起来发生变化。
  • 他们不允许 null 元素。尝试使用 null 元素创建它们会导致 NullPointerException 。
  • 如果所有元素都是可序列化的，则它们是可序列化的。
  • 列表中元素的顺序与提供的参数或提供的数组中元素的顺序相同。
  • 列表及其 subList 视图实现了 RandomAccess 接口。
  • 他们是 value-based 。程序员应该将 equal 实例视为可互换的，不应将它们用于同步，否则可能会发生不可预测的行为。例如，在未来的版本中，同步可能会失败。调用者不应假设返回实例的身份。工厂可以自由创建新实例或重用现有实例。
  • 它们按照 Serialized Form 页面上的指定进行序列化。

此接口是 Java 集合框架 的成员。

自从：
1.2
参见：

  • 方法总结

    修饰符和类型
    方法
    描述
    void
    add(int index, E element)
    在此list中的指定位置插入指定元素（可选操作）。
    boolean
    add(E e)
    将指定的元素附加到此list的末尾（可选操作）。
    boolean
    addAll(int index, Collection<? extends E> c)
    将指定集合中的所有元素插入此list的指定位置（可选操作）。
    boolean
    addAll(Collection<? extends E> c)
    将指定集合中的所有元素附加到此list的末尾，按照它们由指定集合的迭代器返回的顺序（可选操作）。
    void
    clear()
    从此list中删除所有元素（可选操作）。
    boolean
    contains(Object o)
    如果此list包含指定元素，则返回 true。
    boolean
    containsAll(Collection<?> c)
    如果此list包含指定集合的所有元素，则返回 true。
    static <E> List<E>
    copyOf(Collection<? extends E> coll)
    返回一个 不可修改的列表 包含给定 Collection 的元素，按其迭代顺序。
    boolean
    equals(Object o)
    比较指定对象与此list是否相等。
    E
    get(int index)
    返回此list中指定位置的元素。
    int
    hashCode()
    返回此list的哈希码值。
    int
    indexOf(Object o)
    返回此list中指定元素第一次出现的索引，如果此list不包含该元素，则返回 -1。
    boolean
    isEmpty()
    如果此list不包含任何元素，则返回 true。
    Iterator<E>
    iterator()
    以正确的顺序返回此list中元素的迭代器。
    int
    lastIndexOf(Object o)
    返回此list中指定元素最后一次出现的索引，如果此list不包含该元素，则返回 -1。
    ListIterator<E>
    listIterator()
    返回此list中元素的列表迭代器（以正确的顺序）。
    ListIterator<E>
    listIterator(int index)
    返回此list中元素的列表迭代器（以适当的顺序），从列表中的指定位置开始。
    static <E> List<E>
    of()
    返回包含零个元素的不可修改列表。
    static <E> List<E>
    of(E e1)
    返回包含一个元素的不可修改列表。
    static <E> List<E>
    of(E... elements)
    返回包含任意数量元素的不可修改列表。
    static <E> List<E>
    of(E e1, E e2)
    返回包含两个元素的不可修改列表。
    static <E> List<E>
    of(E e1, E e2, E e3)
    返回包含三个元素的不可修改列表。
    static <E> List<E>
    of(E e1, E e2, E e3, E e4)
    返回包含四个元素的不可修改列表。
    static <E> List<E>
    of(E e1, E e2, E e3, E e4, E e5)
    返回包含五个元素的不可修改列表。
    static <E> List<E>
    of(E e1, E e2, E e3, E e4, E e5, E e6)
    返回包含六个元素的不可修改列表。
    static <E> List<E>
    of(E e1, E e2, E e3, E e4, E e5, E e6, E e7)
    返回包含七个元素的不可修改列表。
    static <E> List<E>
    of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8)
    返回包含八个元素的不可修改列表。
    static <E> List<E>
    of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9)
    返回包含九个元素的不可修改的列表。
    static <E> List<E>
    of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10)
    返回包含十个元素的不可修改的列表。
    E
    remove(int index)
    删除此list中指定位置的元素（可选操作）。
    boolean
    remove(Object o)
    从此list中删除第一次出现的指定元素（如果存在）（可选操作）。
    boolean
    removeAll(Collection<?> c)
    从此list中删除指定集合中包含的所有元素（可选操作）。
    default void
    replaceAll(UnaryOperator<E> operator)
    将此list的每个元素替换为对该元素应用运算符的结果。
    boolean
    retainAll(Collection<?> c)
    仅保留此list中包含在指定集合中的元素（可选操作）。
    E
    set(int index, E element)
    用指定的元素替换此list中指定位置的元素（可选操作）。
    int
    size()
    返回此list中的元素数。
    default void
    sort(Comparator<? super E> c)
    根据指定的 Comparator 引起的顺序对该列表进行排序。
    default Spliterator<E>
    spliterator()
    在此list中的元素上创建一个 Spliterator 。
    List<E>
    subList(int fromIndex, int toIndex)
    返回此list中指定的 fromIndex（含）和 toIndex（不含）之间的部分的视图。
    Object[]
    toArray()
    返回一个数组，其中包含此list中按正确顺序（从第一个元素到最后一个元素）的所有元素。
    <T> T[]
    toArray(T[] a)
    以正确的顺序（从第一个元素到最后一个元素）返回一个包含此list中所有元素的数组；返回数组的运行时类型是指定数组的类型。

    在接口 java.util.Collection 中声明的方法

    parallelStream, removeIf, stream, toArray

    在接口 java.lang.Iterable 中声明的方法

    forEach

  • 方法详情

    • size

      int size()
      返回此list中的元素数。如果此list包含超过 Integer.MAX_VALUE 个元素，则返回 Integer.MAX_VALUE 。
      指定者：
      size 在接口 Collection<E> 中
      返回：
      此list中的元素数

    • isEmpty

      boolean isEmpty()
      如果此list不包含任何元素，则返回 true。
      指定者：
      isEmpty 在接口 Collection<E> 中
      返回：
      true 如果这个列表不包含任何元素

    • contains

      boolean contains(Object  o)
      如果此list包含指定元素，则返回 true。更正式地说，返回 true 当且仅当此list包含至少一个元素 e 使得 Objects.equals(o, e) 。
      指定者：
      contains 在接口 Collection<E> 中
      参数：
      o - 要测试其在此list中是否存在的元素
      返回：
      true 如果这个列表包含指定的元素
      抛出：
      ClassCastException - 如果指定元素的类型与此list不兼容 (optional)
      NullPointerException - 如果指定元素为空且此list不允许空元素 (optional)

    • iterator

      Iterator <E > iterator()
      以正确的顺序返回此list中元素的迭代器。
      指定者：
      iterator 在接口 Collection<E> 中
      指定者：
      iterator 在接口 Iterable<E> 中
      返回：
      按正确顺序遍历此list中的元素的迭代器

    • toArray

      Object [] toArray()
      返回一个数组，其中包含此list中按正确顺序（从第一个元素到最后一个元素）的所有元素。

      返回的数组将是“安全的”，因为此list不维护对它的引用。 （换句话说，此方法必须分配一个新数组，即使此list由数组支持）。调用者因此可以自由修改返回的数组。

      此方法充当基于数组和基于集合的 API 之间的桥梁。

      指定者：
      toArray 在接口 Collection<E> 中
      返回：
      按正确顺序包含此list中所有元素的数组
      参见：

    • toArray

      <T> T[] toArray(T[] a)
      以正确的顺序（从第一个元素到最后一个元素）返回一个包含此list中所有元素的数组；返回数组的运行时类型是指定数组的类型。如果列表适合指定的数组，则在其中返回。否则，将使用指定数组的运行时类型和此list的大小分配一个新数组。

      如果列表适合指定的数组并有剩余空间（即数组的元素多于列表），则紧接列表末尾的数组中的元素设置为 null 。 （这对于确定列表的长度很有用仅有的如果调用者知道列表不包含任何空元素。）

      与 toArray() 方法一样，此方法充当基于数组和基于集合的 API 之间的桥梁。此外，此方法允许精确控制输出数组的运行时类型，并且在某些情况下可用于节省分配成本。

      假设 x 是已知仅包含字符串的列表。以下代码可用于将列表转储到新分配的 String 数组中：

      
   String[] y = x.toArray(new String[0]);
      请注意，toArray(new Object[0]) 在功能上与 toArray() 相同。
      指定者：
      toArray 在接口 Collection<E> 中
      类型参数：
      T - 包含集合的数组的组件类型
      参数：
      a - 存储列表元素的数组，如果它足够大的话；否则，为此分配一个相同运行时类型的新数组。
      返回：
      包含此list元素的数组
      抛出：
      ArrayStoreException - 如果指定数组的运行时类型不是此list中每个元素的运行时类型的超类型
      NullPointerException - 如果指定数组为空

    • add

      boolean add(E  e)
      将指定的元素附加到此list的末尾（可选操作）。

      支持此操作的列表可能会限制可以添加到此list的元素。特别是，一些列表会拒绝添加空元素，而另一些列表会对可能添加的元素类型施加限制。列表类应在其文档中明确指定对可以添加的元素的任何限制。

      指定者：
      add 在接口 Collection<E> 中
      参数：
      e - 要附加到此list的元素
      返回：
      true（由 Collection.add(E) 指定）
      抛出：
      UnsupportedOperationException - 如果此list不支持 add 操作
      ClassCastException - 如果指定元素的类阻止它被添加到这个列表
      NullPointerException - 如果指定元素为空且此list不允许空元素
      IllegalArgumentException - 如果此元素的某些属性阻止将其添加到此list

    • remove

      boolean remove(Object  o)
      从此list中删除第一次出现的指定元素（如果存在）（可选操作）。如果此list不包含该元素，则它保持不变。更正式地说，删除具有最低索引 i 的元素，这样 Objects.equals(o, get(i)) （如果存在这样的元素）。如果此list包含指定元素，则返回 true（或者等效地，如果此list因调用而更改）。
      指定者：
      remove 在接口 Collection<E> 中
      参数：
      o - 要从此list中删除的元素（如果存在）
      返回：
      true 如果这个列表包含指定的元素
      抛出：
      ClassCastException - 如果指定元素的类型与此list不兼容 (optional)
      NullPointerException - 如果指定元素为空且此list不允许空元素 (optional)
      UnsupportedOperationException - 如果此list不支持 remove 操作

    • containsAll

      boolean containsAll(Collection <?> c)
      如果此list包含指定集合的所有元素，则返回 true。
      指定者：
      containsAll 在接口 Collection<E> 中
      参数：
      c - 要检查此list中是否包含的集合
      返回：
      true 如果此list包含指定集合的所有元素
      抛出：
      ClassCastException - 如果指定集合中的一个或多个元素的类型与此list不兼容 (optional)
      NullPointerException - 如果指定的集合包含一个或多个空元素并且此list不允许空元素 (optional)，或者如果指定的集合为空
      参见：

    • addAll

      boolean addAll(Collection <? extends E > c)
      将指定集合中的所有元素附加到此list的末尾，按照它们由指定集合的迭代器返回的顺序（可选操作）。如果在操作进行时修改了指定的集合，则此操作的行为是未定义的。 （请注意，如果指定的集合是此list并且它是非空的，则会发生这种情况。）
      指定者：
      addAll 在接口 Collection<E> 中
      参数：
      c - 包含要添加到此list的元素的集合
      返回：
      true 如果此list因调用而更改
      抛出：
      UnsupportedOperationException - 如果此list不支持 addAll 操作
      ClassCastException - 如果指定集合的元素的类阻止将其添加到此list
      NullPointerException - 如果指定的集合包含一个或多个空元素并且此list不允许空元素，或者如果指定的集合为空
      IllegalArgumentException - 如果指定集合的某个元素的某些属性阻止它添加到此list
      参见：

    • addAll

      boolean addAll(int index, Collection <? extends E > c)
      将指定集合中的所有元素插入此list的指定位置（可选操作）。将当前位于该位置的元素（如果有）和任何后续元素向右移动（增加它们的索引）。新元素将按照指定集合的迭代器返回的顺序出现在该列表中。如果在操作进行时修改了指定的集合，则此操作的行为是未定义的。 （请注意，如果指定的集合是此list并且它是非空的，则会发生这种情况。）
      参数：
      index - 从指定集合中插入第一个元素的索引
      c - 包含要添加到此list的元素的集合
      返回：
      true 如果此list因调用而更改
      抛出：
      UnsupportedOperationException - 如果此list不支持 addAll 操作
      ClassCastException - 如果指定集合的元素的类阻止将其添加到此list
      NullPointerException - 如果指定的集合包含一个或多个空元素并且此list不允许空元素，或者如果指定的集合为空
      IllegalArgumentException - 如果指定集合的某个元素的某些属性阻止它添加到此list
      IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

    • removeAll

      boolean removeAll(Collection <?> c)
      从此list中删除指定集合中包含的所有元素（可选操作）。
      指定者：
      removeAll 在接口 Collection<E> 中
      参数：
      c - 包含要从此list中删除的元素的集合
      返回：
      true 如果此list因调用而更改
      抛出：
      UnsupportedOperationException - 如果此list不支持 removeAll 操作
      ClassCastException - 如果此list的元素类与指定集合不兼容 (optional)
      NullPointerException - 如果此list包含空元素并且指定的集合不允许空元素 (optional)，或者如果指定的集合为空
      参见：

    • retainAll

      boolean retainAll(Collection <?> c)
      仅保留此list中包含在指定集合中的元素（可选操作）。换句话说，从该列表中删除所有未包含在指定集合中的元素。
      指定者：
      retainAll 在接口 Collection<E> 中
      参数：
      c - 包含要保留在此list中的元素的集合
      返回：
      true 如果此list因调用而更改
      抛出：
      UnsupportedOperationException - 如果此list不支持 retainAll 操作
      ClassCastException - 如果此list的元素类与指定集合不兼容 (optional)
      NullPointerException - 如果此list包含空元素并且指定的集合不允许空元素 (optional)，或者如果指定的集合为空
      参见：

    • replaceAll

      default void replaceAll(UnaryOperator <E > operator)
      将此list的每个元素替换为对该元素应用运算符的结果。操作员抛出的错误或运行时异常被转发给调用者。
      实现要求：
      对于此 list，默认实现等效于： 
      
   final ListIterator<E> li = list.listIterator();
   while (li.hasNext()) {
     li.set(operator.apply(li.next()));
   }
      如果列表的列表迭代器不支持 set 操作，则在替换第一个元素时将抛出 UnsupportedOperationException。
      参数：
      operator - 应用于每个元素的运算符
      抛出：
      UnsupportedOperationException - 如果此list不可修改。如果无法替换元素或者通常不支持修改，实现可能会抛出此异常
      NullPointerException - 如果指定的运算符为空或运算符结果为空值且此list不允许空元素 (optional)
      自从：
      1.8

    • sort

      default void sort(Comparator <? super E > c)
      根据指定的 Comparator 引起的顺序对该列表进行排序。排序是稳定的：此方法不得重新排序相等的元素。

      此list中的所有元素必须是相互比较使用指定的比较器（即，c.compare(e1, e2) 不得为列表中的任何元素 e1 和 e2 抛出 ClassCastException）。

      如果指定的比较器是 null，则此list中的所有元素都必须实现 Comparable 接口，并且应使用元素的 自然排序。

      此list必须是可修改的，但不需要调整大小。

      实现要求：
      默认实现获取一个包含此list中所有元素的数组，对数组进行排序，并迭代此list，从数组中的相应位置重置每个元素。 （这避免了 n2log(n) 尝试对链表进行就地排序所产生的性能。）
      实现注意事项：
      此实现是一种稳定的、自适应的、迭代的合并排序，当输入数组部分排序时需要的比较少于 n lg(n) 次，同时在输入数组随机排序时提供传统合并排序的性能。如果输入数组几乎已排序，则实现需要大约 n 次比较。临时存储要求从用于几乎排序的输入数组的小常量到用于随机排序的输入数组的 n/2 对象引用不等。

      该实现在其输入数组中同样利用升序和降序，并且可以在同一输入数组的不同部分利用升序和降序。它非常适合合并两个或多个排序的数组：简单地连接数组并对结果数组进行排序。

      该实现适配自 Tim Peters 的 Python 列表排序 ( TimSort)。它使用了 Peter McIlroy 的“乐观排序和信息理论复杂性”中的技术，在第四届年度 ACM-SIAM 离散算法研讨会论文集中，第 467-474 页，1993 年 1 月。

      参数：
      c - Comparator 用于比较列表元素。 null 值表示应使用元素的 自然排序
      抛出：
      ClassCastException - 如果列表中包含的元素不是相互比较使用指定的比较器
      UnsupportedOperationException - 如果列表的列表迭代器不支持 set 操作
      IllegalArgumentException - (optional) 如果发现比较器违反 Comparator 合同
      自从：
      1.8

    • clear

      void clear()
      从此list中删除所有元素（可选操作）。此调用返回后列表将为空。
      指定者：
      clear 在接口 Collection<E> 中
      抛出：
      UnsupportedOperationException - 如果此list不支持 clear 操作

    • equals

      boolean equals(Object  o)
      比较指定对象与此list是否相等。返回 true 当且仅当指定的对象也是一个列表，两个列表具有相同的大小，并且两个列表中所有对应的元素对都是equal（两个元素 e1 和 e2 是equalif Objects.equals(e1, e2) .) 换句话说，如果两个列表包含相同顺序的相同元素，则它们被定义为相等。此定义确保 equals 方法在 List 接口的不同实现中正常工作。
      指定者：
      equals 在接口 Collection<E> 中
      重写：
      equals 在类 Object 中
      参数：
      o - 要与此list进行相等比较的对象
      返回：
      true 如果指定的对象等于这个列表
      参见：

    • hashCode

      int hashCode()
      返回此list的哈希码值。列表的哈希码被定义为以下计算的结果： 
      
   int hashCode = 1;
   for (E e : list)
     hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
      这确保 list1.equals(list2) 意味着 list1.hashCode()==list2.hashCode() 对于任何两个列表，list1 和 list2，正如 Object.hashCode() 的一般合同所要求的。
      指定者：
      hashCode 在接口 Collection<E> 中
      重写：
      hashCode 在类 Object 中
      返回：
      此list的哈希码值
      参见：

    • get

      E  get(int index)
      返回此list中指定位置的元素。
      参数：
      index - 要返回的元素的索引
      返回：
      此list中指定位置的元素
      抛出：
      IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

    • set

      E  set(int index, E  element)
      用指定的元素替换此list中指定位置的元素（可选操作）。
      参数：
      index - 要替换的元素的索引
      element - 要存储在指定位置的元素
      返回：
      先前在指定位置的元素
      抛出：
      UnsupportedOperationException - 如果此list不支持 set 操作
      ClassCastException - 如果指定元素的类阻止它被添加到这个列表
      NullPointerException - 如果指定元素为空且此list不允许空元素
      IllegalArgumentException - 如果指定元素的某些属性阻止将其添加到此list
      IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

    • add

      void add(int index, E  element)
      在此list中的指定位置插入指定元素（可选操作）。将当前位于该位置的元素（如果有）和任何后续元素向右移动（将其索引加一）。
      参数：
      index - 要插入指定元素的索引
      element - 要插入的元素
      抛出：
      UnsupportedOperationException - 如果此list不支持 add 操作
      ClassCastException - 如果指定元素的类阻止它被添加到这个列表
      NullPointerException - 如果指定元素为空且此list不允许空元素
      IllegalArgumentException - 如果指定元素的某些属性阻止将其添加到此list
      IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

    • remove

      E  remove(int index)
      删除此list中指定位置的元素（可选操作）。将任何后续元素向左移动（从其索引中减去一个）。返回从列表中删除的元素。
      参数：
      index - 要删除的元素的索引
      返回：
      先前在指定位置的元素
      抛出：
      UnsupportedOperationException - 如果此list不支持 remove 操作
      IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())

    • indexOf

      int indexOf(Object  o)
      返回此list中指定元素第一次出现的索引，如果此list不包含该元素，则返回 -1。更正式地说，返回最低索引 i 这样 Objects.equals(o, get(i)) ，或 -1 如果没有这样的索引。
      参数：
      o - 要搜索的元素
      返回：
      此list中指定元素第一次出现的索引，如果此list不包含该元素，则为 -1
      抛出：
      ClassCastException - 如果指定元素的类型与此list不兼容 (optional)
      NullPointerException - 如果指定元素为空且此list不允许空元素 (optional)

    • lastIndexOf

      int lastIndexOf(Object  o)
      返回此list中指定元素最后一次出现的索引，如果此list不包含该元素，则返回 -1。更正式地说，返回最高索引 i 这样 Objects.equals(o, get(i)) ，或者 -1 如果没有这样的索引。
      参数：
      o - 要搜索的元素
      返回：
      此list中指定元素最后一次出现的索引，如果此list不包含该元素，则为 -1
      抛出：
      ClassCastException - 如果指定元素的类型与此list不兼容 (optional)
      NullPointerException - 如果指定元素为空且此list不允许空元素 (optional)

    • listIterator

      ListIterator <E > listIterator()
      返回此list中元素的列表迭代器（以正确的顺序）。
      返回：
      此list中元素的列表迭代器（按正确顺序）

    • listIterator

      ListIterator <E > listIterator(int index)
      返回此list中元素的列表迭代器（以适当的顺序），从列表中的指定位置开始。指定的索引指示将由对 next 的初始调用返回的第一个元素。对 previous 的初始调用将返回指定索引减一的元素。
      参数：
      index - 从列表迭代器返回的第一个元素的索引（通过调用 next ）
      返回：
      列表中元素的列表迭代器（以适当的顺序），从列表中的指定位置开始
      抛出：
      IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

    • subList

      List <E > subList(int fromIndex, int toIndex)
      返回此list中指定的 fromIndex（含）和 toIndex（不含）之间的部分的视图。 （如果 fromIndex 和 toIndex 相等，则返回列表为空。）返回列表受此list支持，因此返回列表中的非结构更改会反映在此list中，反之亦然。返回的列表支持此list支持的所有可选列表操作。

      此方法消除了对显式范围操作（数组通常存在的那种）的需要。通过传递子列表视图而不是整个列表，任何需要列表的操作都可以用作范围操作。例如，以下习语从列表中删除一系列元素：

      
   list.subList(from, to).clear();
      可以为 indexOf 和 lastIndexOf 构造类似的习语，并且 Collections 类中的所有算法都可以应用于子列表。

      如果后备列表（即这个列表）是结构修改除了通过返回的列表以外的任何方式。 （结构修改是指那些改变此list大小的修改，或者以其他方式扰乱它，以至于正在进行的迭代可能会产生不正确的结果。）

      参数：
      fromIndex - subList 的低端点（包括）
      toIndex - 子列表的高端点（不包括）
      返回：
      此list中指定范围的视图
      抛出：
      IndexOutOfBoundsException - 对于非法端点索引值 (fromIndex < 0 || toIndex > size || fromIndex > toIndex)

    • spliterator

      default Spliterator <E > spliterator()
      在此list中的元素上创建一个 Spliterator 。

      Spliterator 报告 Spliterator.SIZED 和 Spliterator.ORDERED 。实施应记录附加特征值的报告。

      指定者：
      spliterator 在接口 Collection<E> 中
      指定者：
      spliterator 在接口 Iterable<E> 中
      实现要求：
      默认实现创建一个 late-binding spliterator，如下所示：
      • 如果列表是 RandomAccess 的实例，则默认实现创建一个拆分器，它通过调用方法 get(int) 来遍历元素。如果这样的调用导致或将导致 IndexOutOfBoundsException，则拆分器将 fail-fast 并抛出 ConcurrentModificationException。如果列表也是 AbstractList 的实例，则拆分器将使用列表的 modCount 字段来提供额外的 fail-fast 行为。
      • 否则，默认实现从列表的 Iterator 创建一个拆分器。拆分器继承了列表迭代器的fail-fast。
      实现注意事项：
      创建的 Spliterator 还报告 Spliterator.SUBSIZED 。
      返回：
      a Spliterator 覆盖此list中的元素
      自从：
      1.8

    • of

      static <E> List <E> of()
      返回包含零个元素的不可修改列表。有关详细信息，请参阅 不可修改的列表。
      类型参数：
      E - List 的元素类型
      返回：
      一个空的List
      自从：
      9

    • of

      static <E> List <E> of(E e1)
      返回包含一个元素的不可修改列表。有关详细信息，请参阅 不可修改的列表。
      类型参数：
      E - List 的元素类型
      参数：
      e1 - 单个元素
      返回：
      包含指定元素的 List
      抛出：
      NullPointerException - 如果元素是 null
      自从：
      9

    • of

      static <E> List <E> of(E e1, E e2)
      返回包含两个元素的不可修改列表。有关详细信息，请参阅 不可修改的列表。
      类型参数：
      E - List 的元素类型
      参数：
      e1 - 第一个元素
      e2 - 第二个元素
      返回：
      包含指定元素的 List
      抛出：
      NullPointerException - 如果元素是 null
      自从：
      9

    • of

      static <E> List <E> of(E e1, E e2, E e3)
      返回包含三个元素的不可修改列表。有关详细信息，请参阅 不可修改的列表。
      类型参数：
      E - List 的元素类型
      参数：
      e1 - 第一个元素
      e2 - 第二个元素
      e3 - 第三个元素
      返回：
      包含指定元素的 List
      抛出：
      NullPointerException - 如果元素是 null
      自从：
      9

    • of

      static <E> List <E> of(E e1, E e2, E e3, E e4)
      返回包含四个元素的不可修改列表。有关详细信息，请参阅 不可修改的列表。
      类型参数：
      E - List 的元素类型
      参数：
      e1 - 第一个元素
      e2 - 第二个元素
      e3 - 第三个元素
      e4 - 第四个元素
      返回：
      包含指定元素的 List
      抛出：
      NullPointerException - 如果元素是 null
      自从：
      9

    • of

      static <E> List <E> of(E e1, E e2, E e3, E e4, E e5)
      返回包含五个元素的不可修改列表。有关详细信息，请参阅 不可修改的列表。
      类型参数：
      E - List 的元素类型
      参数：
      e1 - 第一个元素
      e2 - 第二个元素
      e3 - 第三个元素
      e4 - 第四个元素
      e5 - 第五个元素
      返回：
      包含指定元素的 List
      抛出：
      NullPointerException - 如果元素是 null
      自从：
      9

    • of

      static <E> List <E> of(E e1, E e2, E e3, E e4, E e5, E e6)
      返回包含六个元素的不可修改列表。有关详细信息，请参阅 不可修改的列表。
      类型参数：
      E - List 的元素类型
      参数：
      e1 - 第一个元素
      e2 - 第二个元素
      e3 - 第三个元素
      e4 - 第四个元素
      e5 - 第五个元素
      e6 - 第六元素
      返回：
      包含指定元素的 List
      抛出：
      NullPointerException - 如果元素是 null
      自从：
      9

    • of

      static <E> List <E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7)
      返回包含七个元素的不可修改列表。有关详细信息，请参阅 不可修改的列表。
      类型参数：
      E - List 的元素类型
      参数：
      e1 - 第一个元素
      e2 - 第二个元素
      e3 - 第三个元素
      e4 - 第四个元素
      e5 - 第五个元素
      e6 - 第六元素
      e7 - 第七元素
      返回：
      包含指定元素的 List
      抛出：
      NullPointerException - 如果元素是 null
      自从：
      9

    • of

      static <E> List <E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8)
      返回包含八个元素的不可修改列表。有关详细信息，请参阅 不可修改的列表。
      类型参数：
      E - List 的元素类型
      参数：
      e1 - 第一个元素
      e2 - 第二个元素
      e3 - 第三个元素
      e4 - 第四个元素
      e5 - 第五个元素
      e6 - 第六元素
      e7 - 第七元素
      e8——第八个元素
      返回：
      包含指定元素的 List
      抛出：
      NullPointerException - 如果元素是 null
      自从：
      9

    • of

      static <E> List <E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9)
      返回包含九个元素的不可修改的列表。有关详细信息，请参阅 不可修改的列表。
      类型参数：
      E - List 的元素类型
      参数：
      e1 - 第一个元素
      e2 - 第二个元素
      e3 - 第三个元素
      e4 - 第四个元素
      e5 - 第五个元素
      e6 - 第六元素
      e7 - 第七元素
      e8——第八个元素
      e9 - 第九个元素
      返回：
      包含指定元素的 List
      抛出：
      NullPointerException - 如果元素是 null
      自从：
      9

    • of

      static <E> List <E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10)
      返回包含十个元素的不可修改的列表。有关详细信息，请参阅 不可修改的列表。
      类型参数：
      E - List 的元素类型
      参数：
      e1 - 第一个元素
      e2 - 第二个元素
      e3 - 第三个元素
      e4 - 第四个元素
      e5 - 第五个元素
      e6 - 第六元素
      e7 - 第七元素
      e8——第八个元素
      e9 - 第九个元素
      e10 - 第十个元素
      返回：
      包含指定元素的 List
      抛出：
      NullPointerException - 如果元素是 null
      自从：
      9

    • of

      @SafeVarargs static <E> List <E> of(E... elements)
      返回包含任意数量元素的不可修改列表。有关详细信息，请参阅 不可修改的列表。
      API 注意：
      此方法还接受单个数组作为参数。结果列表的元素类型将是数组的组件类型，列表的大小将等于数组的长度。要创建包含一个数组元素的列表，请执行以下操作： 
      
   String[] array = ... ;
   List<String[]> list = List.<String[]>of(array);
      这将导致调用 List.of(E) 方法。
      类型参数：
      E - List 的元素类型
      参数：
      elements - 要包含在列表中的元素
      返回：
      包含指定元素的 List
      抛出：
      NullPointerException - 如果元素是 null 或者数组是 null
      自从：
      9

    • copyOf

      static <E> List <E> copyOf(Collection <? extends E> coll)
      返回一个 不可修改的列表 包含给定 Collection 的元素，按其迭代顺序。给定的 Collection 不能为 null，并且不能包含任何 null 元素。如果给定的 Collection 随后被修改，则返回的 List 将不会反映此类修改。
      实现注意事项：
      如果给定的 Collection 是 不可修改的列表 ，调用 copyOf 通常不会创建副本。
      类型参数：
      E - List 的元素类型
      参数：
      coll - 从中提取元素的 Collection 必须为非空
      返回：
      一个 List 包含给定 Collection 的元素
      抛出：
      NullPointerException - 如果 coll 为空，或者它包含任何空值
      自从：
      10