模块  java.base
软件包  java.util

Interface List<E>

  • 参数类型
    E - 此列表中的元素类型
    All Superinterfaces:
    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接口放置额外的约定，超过指定Collection接口上的合同iterator ， add ， remove ， equals和hashCode方法。 为方便起见，此处还包括其他继承方法的声明。

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

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

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

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

    注意：虽然允许列表将自己包含为元素，但建议极为谨慎： equals和hashCode方法不再在此类列表中定义良好。

    某些列表实现对它们可能包含的元素有限制。 例如，某些实现禁止null元素，并且一些实现对其元素的类型有限制。 尝试添加不合格的元素会引发未经检查的异常，通常为NullPointerException或ClassCastException 。 试图查询不合格元素的存在可能会引发异常，或者它可能只是返回false; 一些实现将展示前一种行为，一些将展示后者。 更一般地，在完成不会导致将不合格元素插入列表的不合格元素上尝试操作可能会引发异常，或者可能在实现的选择中成功。 此类异常在此接口的规范中标记为“可选”。

    Unmodifiable Lists

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

    • 他们是unmodifiable 。 无法添加，删除或替换元素。 在List上调用任何mutator方法将始终导致UnsupportedOperationException被抛出。 但是，如果包含的元素本身是可变的，则可能导致List的内容看起来发生变化。
    • 他们不允许null元素。 尝试使用null元素创建它们导致NullPointerException 。
    • 如果所有元素都可序列化，则它们是可序列化的。
    • 列表中元素的顺序与提供的参数的顺序或提供的数组中的元素的顺序相同。
    • 他们是value-based 。 调用者不应对返回实例的身份做出任何假设。 工厂可以自由创建新实例或重用现有实例。 因此，对这些实例的身份敏感操作（引用相等（ == ），标识哈希代码和同步）是不可靠的，应该避免。
    • 它们按照Serialized Form页面上的规定进行序列化。

    此界面是Java Collections Framework的成员。

    从以下版本开始：
    1.2
    另请参见：
    Collection ， Set ， ArrayList ， LinkedList ， Vector ， Arrays.asList(Object[]) ， Collections.nCopies(int, Object) ， Collections.EMPTY_LIST ， AbstractList ， AbstractSequentialList

    • 方法摘要

      所有方法  静态方法  实例方法 抽象方法  Default Methods 
      变量和类型 方法 描述
      void add​(int index, E element)
      将指定元素插入此列表中的指定位置（可选操作）。
      boolean add​(E e)
      将指定的元素追加到此列表的末尾（可选操作）。
      boolean addAll​(int index, Collection<? extends E> c)
      将指定集合中的所有元素插入到指定位置的此列表中（可选操作）。
      boolean addAll​(Collection<? extends E> c)
      将指定集合中的所有元素按指定集合的迭代器（可选操作）返回的顺序追加到此列表的末尾。
      void clear()
      从此列表中删除所有元素（可选操作）。
      boolean contains​(Object o)
      如果此列表包含指定的元素，则返回 true 。
      boolean containsAll​(Collection<?> c)
      如果此列表包含指定集合的所有元素，则返回 true 。
      static <E> List<E> copyOf​(Collection<? extends E> coll)
      以迭代顺序返回包含给定Collection的元素的 unmodifiable List 。
      boolean equals​(Object o)
      将指定对象与此列表进行比较以获得相等性。
      E get​(int index)
      返回此列表中指定位置的元素。
      int hashCode()
      返回此列表的哈希码值。
      int indexOf​(Object o)
      返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
      boolean isEmpty()
      如果此列表不包含任何元素，则返回 true 。
      Iterator<E> iterator()
      以适当的顺序返回此列表中元素的迭代器。
      int lastIndexOf​(Object o)
      返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
      ListIterator<E> listIterator()
      返回此列表中元素的列表迭代器（按适当顺序）。
      ListIterator<E> listIterator​(int index)
      从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。
      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)
      删除此列表中指定位置的元素（可选操作）。
      boolean remove​(Object o)
      从该列表中删除指定元素的第一个匹配项（如果存在）（可选操作）。
      boolean removeAll​(Collection<?> c)
      从此列表中删除指定集合中包含的所有元素（可选操作）。
      default void replaceAll​(UnaryOperator<E> operator)
      将该列表的每个元素替换为将运算符应用于该元素的结果。
      boolean retainAll​(Collection<?> c)
      仅保留此列表中包含在指定集合中的元素（可选操作）。
      E set​(int index, E element)
      用指定的元素替换此列表中指定位置的元素（可选操作）。
      int size()
      返回此列表中的元素数。
      default void sort​(Comparator<? super E> c)
      根据指定的Comparator引发的顺序对此列表进行排序。
      default Spliterator<E> spliterator()
      在此列表中的元素上创建Spliterator 。
      List<E> subList​(int fromIndex, int toIndex)
      返回指定的 fromIndex （包含）和 toIndex （不包括）之间的此列表部分的视图。
      Object[] toArray()
      以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。
      <T> T[] toArray​(T[] a)
      以适当的顺序返回包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。

    • 方法详细信息

      • size

        int size()
        返回此列表中的元素数。 如果此列表包含超过Integer.MAX_VALUE元素，则返回Integer.MAX_VALUE 。
        Specified by:
        size in interface Collection<E>
        结果
        此列表中的元素数量

      • isEmpty

        boolean isEmpty()
        如果此列表不包含任何元素，则返回 true 。
        Specified by:
        isEmpty在界面 Collection<E>
        结果
        true如果此列表不包含任何元素

      • contains

        boolean contains​(Object o)
        如果此列表包含指定的元素，则返回true 。 更正式地说，返回true当且仅当此列表包含至少一个元素e ，使得Objects.equals(o, e) 。
        Specified by:
        contains在界面 Collection<E>
        参数
        o - 要测试其在此列表中的存在的元素
        结果
        true如果此列表包含指定的元素
        异常
        ClassCastException - 如果指定元素的类型与此列表不兼容（ optional ）
        NullPointerException - 如果指定的元素为null且此列表不允许null元素（ optional ）

      • iterator

        Iterator<E> iterator()
        以适当的顺序返回此列表中元素的迭代器。
        Specified by:
        iterator在界面 Collection<E>
        Specified by:
        iterator在界面 Iterable<E>
        结果
        以适当的顺序在此列表中的元素上的迭代器

      • toArray

        Object[] toArray()
        以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。

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

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

        Specified by:
        toArray在界面 Collection<E>
        结果
        一个数组，以适当的顺序包含此列表中的所有元素
        另请参见：
        Arrays.asList(Object[])

      • toArray

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

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

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

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

           String[] y = x.toArray(new String[0]);
        请注意， toArray(new Object[0])功能与toArray()相同。
        Specified by:
        toArray在界面 Collection<E>
        参数类型
        T - 要包含集合的数组的组件类型
        参数
        a - 要存储此列表元素的数组（如果足够大）; 否则，为此目的分配相同运行时类型的新数组。
        结果
        包含此列表元素的数组
        异常
        ArrayStoreException - 如果指定数组的运行时类型不是此列表中每个元素的运行时类型的超类型
        NullPointerException - 如果指定的数组为null

      • add

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

        支持此操作的列表可能会限制可能添加到此列表的元素。 特别是，某些列表将拒绝添加null元素，而其他列表将对可能添加的元素类型施加限制。 列表类应在其文档中明确指出可以添加哪些元素的任何限制。

        Specified by:
        add在界面 Collection<E>
        参数
        e - 要附加到此列表的元素
        结果
        true （由 Collection.add(E)指定）
        异常
        UnsupportedOperationException - 如果此列表不支持 add操作
        ClassCastException - 如果指定元素的类阻止将其添加到此列表中
        NullPointerException - 如果指定的元素为null且此列表不允许null元素
        IllegalArgumentException - 如果此元素的某些属性阻止将其添加到此列表中

      • remove

        boolean remove​(Object o)
        从该列表中删除指定元素的第一个匹配项（如果存在）（可选操作）。 如果此列表不包含该元素，则不会更改。 更正式地，删除具有最低索引i的元素，使得Objects.equals(o, get(i)) （如果存在这样的元素）。 如果此列表包含指定的元素，则返回true （或等效地，如果此列表因调用而更改）。
        Specified by:
        remove在界面 Collection<E>
        参数
        o - 要从此列表中删除的元素（如果存在）
        结果
        true如果此列表包含指定的元素
        异常
        ClassCastException - 如果指定元素的类型与此列表不兼容（ optional ）
        NullPointerException - 如果指定的元素为null且此列表不允许null元素（ optional ）
        UnsupportedOperationException - 如果此列表不支持 remove操作

      • containsAll

        boolean containsAll​(Collection<?> c)
        如果此列表包含指定集合的所有元素，则返回 true 。
        Specified by:
        containsAll在界面 Collection<E>
        参数
        c - 要在此列表中检查包含的集合
        结果
        true如果此列表包含指定集合的所有元素
        异常
        ClassCastException - 如果指定集合中的一个或多个元素的类型与此列表不兼容（ optional ）
        NullPointerException - 如果指定的集合包含一个或多个null元素，并且此列表不允许null元素（ optional ），或者指定的集合为null
        另请参见：
        contains(Object)

      • addAll

        boolean addAll​(Collection<? extends E> c)
        将指定集合中的所有元素按指定集合的迭代器（可选操作）返回的顺序追加到此列表的末尾。 如果在操作正在进行时修改了指定的集合，则此操作的行为是不确定的。 （请注意，如果指定的集合是此列表，则会发生这种情况，并且它是非空的。）
        Specified by:
        addAll在界面 Collection<E>
        参数
        c - 包含要添加到此列表的元素的集合
        结果
        true如果此列表因呼叫而更改
        异常
        UnsupportedOperationException - 如果此列表不支持 addAll操作
        ClassCastException - 如果指定集合的元素的类阻止将其添加到此列表中
        NullPointerException - 如果指定的集合包含一个或多个null元素，并且此列表不允许null元素，或者指定的集合为null
        IllegalArgumentException - 如果指定集合的某个元素的某些属性阻止将其添加到此列表中
        另请参见：
        add(Object)

      • addAll

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

      • retainAll

        boolean retainAll​(Collection<?> c)
        仅保留此列表中包含在指定集合中的元素（可选操作）。 换句话说，从该列表中删除未包含在指定集合中的所有元素。
        Specified by:
        retainAll在界面 Collection<E>
        参数
        c - 包含要在此列表中保留的元素的集合
        结果
        true如果此列表因呼叫而更改
        异常
        UnsupportedOperationException - 如果此列表不支持 retainAll
        ClassCastException - 如果此列表的元素的类与指定的集合不兼容（ optional ）
        NullPointerException - 如果此列表包含null元素且指定的集合不允许null元素（ optional ），或者指定的集合为null
        另请参见：
        remove(Object) ， contains(Object)

      • replaceAll

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

      • sort

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

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

        如果指定的比较器为null则此列表中的所有元素必须实现Comparable接口，并且应使用元素' natural ordering 。

        此列表必须是可修改的，但无需调整大小。

        实现要求：
        默认实现获取包含此列表中所有元素的数组，对数组进行排序，并迭代此列表，从数组中的相应位置重置每个元素。 （这样可以避免尝试对链接列表进行排序所导致的n 2 log（n）性能。）
        Implementation Note:
        此实现是一个稳定的，自适应的迭代合并输出，当输入数组被部分排序时，它需要远远少于n lg（n）的比较，同时在输入数组随机排序时提供传统合并输出的性能。 如果输入数组几乎排序，则实现需要大约n次比较。 临时存储要求从几乎排序的输入数组的小常量到随机排序的输入数组的n / 2个对象引用不等。

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

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

        参数
        c - 用于比较列表元素的Comparator 。 null值表示应使用元素' natural ordering
        异常
        ClassCastException - 如果列表包含使用指定比较器无法 相互比较的元素
        UnsupportedOperationException - 如果列表的list-iterator不支持 set操作
        IllegalArgumentException - （ optional ）若发现比较器有违反Comparator的合约
        从以下版本开始：
        1.8

      • clear

        void clear()
        从此列表中删除所有元素（可选操作）。 此调用返回后，列表将为空。
        Specified by:
        clear在界面 Collection<E>
        异常
        UnsupportedOperationException - 如果此列表不支持 clear

      • equals

        boolean equals​(Object o)
        将指定对象与此列表进行比较以获得相等性。 当且仅当指定的对象也是列表时，返回true ，两个列表具有相同的大小，并且两个列表中的所有对应元素对都相等 。 （两个元件e1和e2是如果相等 Objects.equals(e1, e2) ）。换句话说，两个列表被定义为等于如果它们包含以相同的顺序相同的元件。 此定义确保equals方法在List接口的不同实现中正常工作。
        Specified by:
        equals在界面 Collection<E>
        重写：
        equals类 Object
        参数
        o - 要与此列表进行相等性比较的对象
        结果
        true如果指定的对象等于此列表
        另请参见：
        Object.hashCode() ， HashMap

      • hashCode

        int hashCode()
        返回此列表的哈希码值。 列表的哈希码被定义为以下计算的结果： 
           int hashCode = 1; for (E e : list) hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
        这确保list1.equals(list2)暗示list1.hashCode()==list2.hashCode()对于任何两个列表， list1和list2 ，根据list2的一般合同的要求 。
        Specified by:
        hashCode在界面 Collection<E>
        重写：
        hashCode在类 Object
        结果
        此列表的哈希码值
        另请参见：
        Object.equals(Object) ， equals(Object)

      • get

        E get​(int index)
        返回此列表中指定位置的元素。
        参数
        index - 要返回的元素的索引
        结果
        此列表中指定位置的元素
        异常
        IndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index >= size() ）

      • set

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

      • add

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

      • remove

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

      • indexOf

        int indexOf​(Object o)
        返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。 更正式的是，返回最低指数i如Objects.equals(o, get(i)) ，如果没有这样的指数则返回-1。
        参数
        o - 要搜索的元素
        结果
        此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1
        异常
        ClassCastException - 如果指定元素的类型与此列表不兼容（ optional ）
        NullPointerException - 如果指定的元素为null且此列表不允许null元素（ optional ）

      • lastIndexOf

        int lastIndexOf​(Object o)
        返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。 更正式的是，返回最高指数i如Objects.equals(o, get(i)) ，如果没有这样的指数则为-1。
        参数
        o - 要搜索的元素
        结果
        此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1
        异常
        ClassCastException - 如果指定元素的类型与此列表不兼容（ optional ）
        NullPointerException - 如果指定的元素为null且此列表不允许null元素（ optional ）

      • listIterator

        ListIterator<E> listIterator()
        返回此列表中元素的列表迭代器（按适当顺序）。
        结果
        列表中的元素列表迭代器（按正确顺序）

      • listIterator

        ListIterator<E> listIterator​(int index)
        从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。 指定的索引指示初始调用next将返回的第一个元素。 对previous的初始调用将返回指定索引减去1的元素。
        参数
        index - 从列表迭代器返回的第一个元素的索引（通过调用 next ）
        结果
        列表中元素的列表迭代器（按正确顺序），从列表中的指定位置开始
        异常
        IndexOutOfBoundsException - 若索引超出范围（ index < 0 || index > size() ）

      • subList

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

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

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

        如果支持列表（即此列表）在结构上以除返回列表之外的任何方式进行变量 ，则此方法返回的列表的语义将变为未定义。 （结构修改是那些改变了这个列表的大小，或以其他方式扰乱它的方式，正在进行的迭代可能会产生不正确的结果。）

        参数
        fromIndex - fromIndex低端点（包括）
        toIndex - toIndex高端点（不包括）
        结果
        此列表中指定范围的视图
        异常
        IndexOutOfBoundsException - 用于非法端点索引值（ fromIndex < 0 || toIndex > size || fromIndex > toIndex ）

      • spliterator

        default Spliterator<E> spliterator()
        在此列表中的元素上创建Spliterator 。

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

        Specified by:
        spliterator在界面 Collection<E>
        Specified by:
        spliterator在界面 Iterable<E>
        实现要求：
        默认实现创建一个late-binding spliterator，如下所示：
        • 如果列表是RandomAccess的实例，则默认实现会创建一个通过调用方法get(int)遍历元素的spliterator 。 如果这样的调用导致或将导致IndexOutOfBoundsException那么分裂器将快速失败并抛出ConcurrentModificationException 。 如果列表也是AbstractList的实例，则spliterator将使用列表的modCount字段来提供其他快速失败行为。
        • 否则，默认实现从列表的Iterator创建一个Iterator 。 spliterator继承了列表迭代器的fail-fast 。
        Implementation Note:
        创建的 Spliterator另外报告 Spliterator.SUBSIZED 。
        结果
        这个列表中的元素是 Spliterator
        从以下版本开始：
        1.8

      • of

        static <E> List<E> of()
        返回包含零元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        参数类型
        E - List的元素类型
        结果
        空 List
        从以下版本开始：
        9

      • of

        static <E> List<E> of​(E e1)
        返回包含一个元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        参数类型
        E - List的元素类型
        参数
        e1 - 单个元素
        结果
        包含指定元素的 List
        异常
        NullPointerException - 如果元素是 null
        从以下版本开始：
        9

      • of

        static <E> List<E> of​(E e1,
                      E e2)
        返回包含两个元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        参数类型
        E - List的元素类型
        参数
        e1 - 第一个元素
        e2 - 第二个要素
        结果
        包含指定元素的 List
        异常
        NullPointerException - 如果元素是 null
        从以下版本开始：
        9

      • of

        static <E> List<E> of​(E e1,
                      E e2,
                      E e3)
        返回包含三个元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        参数类型
        E - List的元素类型
        参数
        e1 - 第一个元素
        e2 - 第二个要素
        e3 - 第三个要素
        结果
        包含指定元素的 List
        异常
        NullPointerException - 如果元素是 null
        从以下版本开始：
        9

      • of

        static <E> List<E> of​(E e1,
                      E e2,
                      E e3,
                      E e4)
        返回包含四个元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        参数类型
        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)
        返回包含五个元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        参数类型
        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)
        返回包含六个元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        参数类型
        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)
        返回包含七个元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        参数类型
        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)
        返回包含八个元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        参数类型
        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)
        返回包含九个元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        参数类型
        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)
        返回包含十个元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        参数类型
        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)
        返回包含任意数量元素的不可修改列表。 有关详细信息，请参见Unmodifiable Lists 。
        API Note:
        此方法还接受单个数组作为参数。 结果列表的元素类型将是数组的组件类型，列表的大小将等于数组的长度。 要使用作为数组的单个元素创建列表，请执行以下操作： 
           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的元素的unmodifiable List 。 给定的Collection不能为null，并且不能包含任何null元素。 如果随后修改了给定的Collection，则返回的List将不会反映此类修改。
        Implementation Note:
        如果给定的Collection是 unmodifiable List ，则调用copyOf通常不会创建副本。
        参数类型
        E - List的元素类型
        参数
        coll - Collection绘制元素的 Collection必须为非null
        结果
        List包含给定 Collection的元素
        异常
        NullPointerException - 如果coll为null，或者它包含任何空值
        从以下版本开始：
        10