Module java.base

软件包 java.util

Interface List<E>

参数类型

E - 此列表中元素的类型

All Superinterfaces:

Collection<E> ， Iterable<E>

All Known Subinterfaces:

ObservableList<E> ， ObservableListValue<E> ， WritableListValue<E>

所有已知实现类：

AbstractList ， AbstractSequentialList ， ArrayList ， AttributeList ， CopyOnWriteArrayList ， FilteredList ， LinkedList ， ListBinding ， ListExpression ， ListProperty ， ListPropertyBase ， ModifiableObservableListBase ， ObservableListBase ， ReadOnlyListProperty ， ReadOnlyListPropertyBase ， ReadOnlyListWrapper ， RoleList ， RoleUnresolvedList ， SimpleListProperty ， SortedList ， Stack ， TransformationList ， 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方法在这样的列表中不再被很好的定义。

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

Immutable List Static Factory Methods

List.of()静态工厂方法提供了一种创建不可变列表的方便方法。 由这些方法创建的List实例具有以下特征：

• 它们在结构上是不可变的 。 元素无法添加，删除或替换。 调用任何mutator方法将总是导致UnsupportedOperationException被抛出。 但是，如果包含的元素本身是可变的，则可能会导致列表的内容出现更改。
• 他们不允许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

方法摘要

Modifier and Type	方法	描述
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 。
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)	以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。

Methods inherited from interface java.util.Collection

parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable

forEach

方法详细信息

size

int size()

返回此列表中的元素数。 如果此列表包含Integer.MAX_VALUE元素，则返回Integer.MAX_VALUE 。

Specified by:

size在接口 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 - 如果指定的元素为空，并且该列表不允许空元素（ 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 - 如果指定的数组为空

add

boolean add(E e)

将指定的元素追加到此列表的末尾（可选操作）。

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

Specified by:

add在接口 Collection<E>

参数

e - 要附加到此列表的元素

结果

true （由 Collection.add(E)指定）

异常

UnsupportedOperationException - 如果此列表不支持 add操作

ClassCastException - 如果指定元素的类阻止将其添加到此列表中

NullPointerException - 如果指定的元素为空，并且该列表不允许空元素

IllegalArgumentException - 如果此元素的某些属性阻止将其添加到此列表

remove

boolean remove(Object o)

从列表中删除指定元素的第一个出现（如果存在）（可选操作）。 如果此列表不包含该元素，则它将保持不变。 更正式地，删除具有最低索引i的元素，使得Objects.equals(o, get(i)) （如果这样的元素存在）。 如果此列表包含指定的元素（或等效地，如果此列表作为调用的结果而更改），则返回true 。

Specified by:

remove在接口 Collection<E>

参数

o - 要从此列表中删除的元素（如果存在）

结果

true如果此列表包含指定的元素

异常

ClassCastException - 如果指定元素的类型与此列表不兼容（ optional ）

NullPointerException - 如果指定的元素为空，此列表不允许空元素（ optional ）

UnsupportedOperationException - 如果此列表不支持 remove操作

containsAll

boolean containsAll(Collection<?> c)

如果此列表包含指定集合的所有元素，则返回 true 。

Specified by:

containsAll在接口 Collection<E>

参数

c - 要在此列表中检查遏制的集合

结果

true如果此列表包含指定集合的所有元素

异常

ClassCastException - 如果指定集合中的一个或多个元素的类型与此列表不兼容（ optional ）

NullPointerException - 如果指定的集合包含一个或多个空元素，并且该列表不允许空元素（ optional ），或者如果指定的集合为空

另请参见：

contains(Object)

addAll

boolean addAll(Collection<? extends E> c)

按指定集合的迭代器（可选操作）返回的顺序将指定集合中的所有元素附加到此列表的末尾。 如果在操作进行中修改了指定的集合，则此操作的行为是未定义的。 （注意，如果指定的集合是此列表，并且它是非空的，则会发生这种情况。）

Specified by:

addAll在接口 Collection<E>

参数

c - 包含要添加到此列表中的元素的集合

结果

true如果此列表因呼叫而更改

异常

UnsupportedOperationException - 如果此列表不支持 addAll操作

ClassCastException - 如果指定集合的元素的类阻止将其添加到此列表中

NullPointerException - 如果指定的集合包含一个或多个空元素，并且此列表不允许空元素，或者如果指定的集合为空

IllegalArgumentException - 如果指定集合的元素的某些属性阻止其添加到此列表中

另请参见：

add(Object)

addAll

boolean addAll(int index,
               Collection<? extends E> c)

将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。 将当前位于该位置（如果有的话）的元素和随后的任何元素移动到右边（增加其索引）。 新元素将按照指定集合的迭代器返回的顺序显示在此列表中。 如果在操作进行中修改了指定的集合，则此操作的行为是未定义的。 （注意，如果指定的集合是此列表，并且它是非空的，则会发生这种情况。）

参数

index - 从中指定集合插入第一个元素的索引

c - 包含要添加到此列表的元素的集合

结果

true如果此列表因呼叫而更改

异常

UnsupportedOperationException - 如果此列表不支持 addAll操作

ClassCastException - 如果指定集合的元素的类阻止将其添加到此列表

NullPointerException - 如果指定的集合包含一个或多个空元素，并且该列表不允许空元素，或者如果指定的集合为空

IllegalArgumentException - 如果指定集合的元素的某些属性阻止将其添加到此列表

IndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index > size() ）

removeAll

boolean removeAll(Collection<?> c)

从此列表中删除包含在指定集合中的所有元素（可选操作）。

Specified by:

removeAll在接口 Collection<E>

参数

c - 包含要从此列表中删除的元素的集合

结果

true如果此列表因呼叫而更改

异常

UnsupportedOperationException - 如果此列表不支持 removeAll操作

ClassCastException - 如果此列表的元素的类与指定的集合不兼容（ optional ）

NullPointerException - 如果此列表包含空元素，并且指定的集合不允许空元素（ optional ），或者如果指定的集合为空

另请参见：

remove(Object) ， contains(Object)

retainAll

boolean retainAll(Collection<?> c)

仅保留此列表中包含在指定集合中的元素（可选操作）。 换句话说，从此列表中删除其中不包含在指定集合中的所有元素。

Specified by:

retainAll在接口 Collection<E>

参数

c - 包含要保留在此列表中的元素的集合

结果

true如果此列表因呼叫而更改

异常

UnsupportedOperationException - 如果此列表不支持 retainAll操作

ClassCastException - 如果此列表的元素的类与指定的集合不兼容（ optional ）

NullPointerException - 如果此列表包含空元素，并且指定的集合不允许空元素（ optional ），或者如果指定的集合为空

另请参见：

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 - 如果指定的运算符为空，或者运算符结果为空值，并且该列表不允许空元素（ optional ）

从以下版本开始：

1.8

sort

default void sort(Comparator<? super E> c)

根据指定的Comparator引发的顺序排列此列表。

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

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

该列表必须是可修改的，但不能调整大小。

实现要求：

默认实现获取包含此列表中所有元素的数组，对数组进行排序，然后迭代该列表，从数组中的相应位置重新设置每个元素。 （这样可以避免尝试对现有的链表进行排序而导致的n ² log（n）性能。）

Implementation Note:

这个实现是一个稳定的，自适应的，迭代的mergeesort，当输入数组被部分排序时，它需要比n lg（n）比较少的比较，同时在输入数组被随机排列时提供传统的mergeesort的性能。 如果输入数组几乎被排序，则实现需要大致n个比较。 临时存储要求从几乎排序的输入数组的小常数到随机排序的输入数组的n / 2对象引用。

该实现在其输入数组中具有上升和下降的同等优势，并且可以在同一输入数组的不同部分中利用升序和降序。 它非常适合合并两个或多个排序的数组：简单地连接数组并排序生成的数组。

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

参数

c - 用于比较列表元素的Comparator 。 A 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 - 如果指定的元素为空，并且该列表不允许空元素

IllegalArgumentException - 如果指定元素的某些属性阻止将其添加到此列表中

IndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index >= size() ）

add

void add(int index,
         E element)

将指定的元素插入此列表中的指定位置（可选操作）。 将当前位于该位置的元素（如果有）和任何后续元素（向其索引添加一个）移动。

参数

index - 要在其中插入指定元素的索引

element - 要插入的元素

异常

UnsupportedOperationException - 如果此列表不支持 add操作

ClassCastException - 如果指定元素的类阻止将其添加到此列表中

NullPointerException - 如果指定的元素为空，并且该列表不允许空元素

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 - 如果指定的元素为空，并且此列表不允许空元素（ optional ）

lastIndexOf

int lastIndexOf(Object o)

返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。 更正式地，返回最高指数i如Objects.equals(o, get(i)) ，或-1如果没有这样的指数。

参数

o - 要搜索的元素

结果

此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则为-1

异常

ClassCastException - 如果指定元素的类型与此列表不兼容（ optional ）

NullPointerException - 如果指定的元素为空，并且此列表不允许空元素（ 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相等，则返回的列表为空。）返回的列表由此列表支持，因此返回列表中的非结构性更改将反映在此列表中，反之亦然。 返回的列表支持此列表支持的所有可选列表操作。

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

   list.subList(from, to).clear();  

可以为indexOf和lastIndexOf构造类似的成语，并且可以将Collections类中的所有算法应用于子列表。

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

参数

fromIndex - 子列表的低端点（含）

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分配器，如下所示：

• 如果列表是RandomAccess的实例，则默认实现将通过调用方法get(int)创建一个遍历元素的分割器 。 如果这样的调用结果或者会导致一个IndexOutOfBoundsException那么拼接器将会快速失败并抛出一个ConcurrentModificationException 。 如果列表也是AbstractList的一个实例，那么分割器将使用列表的modCount字段提供额外的故障快速行为。
• 否则，默认实现从列表的Iterator创建一个拼接Iterator 。 分割器继承列表迭代器的故障快速 。

Implementation Note:

创建的 Spliterator另外报告 Spliterator.SUBSIZED 。

结果

一个 Spliterator在这个列表中的元素

从以下版本开始：

1.8

of

static <E> List<E> of()

返回包含零个元素的不可变列表。 详见Immutable List Static Factory Methods 。

参数类型

E - List的元素类型

结果

一个空的 List

从以下版本开始：

9

of

static <E> List<E> of(E e1)

返回一个包含一个元素的不可变列表。 详见Immutable List Static Factory Methods 。

参数类型

E - List的元素类型

参数

e1 - 单一元素

结果

一个 List包含指定的元素

异常

NullPointerException - 如果元素是 null

从以下版本开始：

9

of

static <E> List<E> of(E e1,
                      E e2)

返回一个包含两个元素的不可变列表。 详见Immutable List Static Factory Methods 。

参数类型

E - List的元素类型

参数

e1 - 第一个元素

e2 - 第二个元素

结果

一个包含指定元素的 List

异常

NullPointerException - 如果一个元素是 null

从以下版本开始：

9

of

static <E> List<E> of(E e1,
                      E e2,
                      E e3)

返回一个包含三个元素的不可变列表。 详见Immutable List Static Factory Methods 。

参数类型

E - List的元素类型

参数

e1 - 第一个元素

e2 - 第二个元素

e3 - 第三个元素

结果

一个 List包含指定的元素

异常

NullPointerException - 如果一个元素是 null

从以下版本开始：

9

of

static <E> List<E> of(E e1,
                      E e2,
                      E e3,
                      E e4)

返回一个包含四个元素的不可变列表。 详见Immutable List Static Factory Methods 。

参数类型

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)

返回包含五个元素的不可变列表。 详见Immutable List Static Factory Methods 。

参数类型

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)

返回包含六个元素的不可变列表。 详见Immutable List Static Factory Methods 。

参数类型

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)

返回包含七个元素的不可变列表。 详见Immutable List Static Factory Methods 。

参数类型

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)

返回包含八个元素的不可变列表。 详见Immutable List Static Factory Methods 。

参数类型

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)

返回包含九个元素的不可变列表。 详见Immutable List Static Factory Methods 。

参数类型

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)

返回一个包含十个元素的不可变列表。 详见Immutable List Static Factory Methods 。

参数类型

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)

返回包含任意数量元素的不可变列表。 详见Immutable List Static Factory Methods 。

API Note:

该方法也接受一个数组作为参数。 结果列表的元素类型将是数组的组件类型，列表的大小将等于数组的长度。 要使用单个元素创建一个数组，请执行以下操作：

   String[] array = ... ; List<String[]> list = List.<String[]>of(array);  

这将导致List.of(E)方法被调用。

参数类型

E - List的元素类型

参数

elements - 要包含在列表中的元素

结果

一个包含指定元素的 List

异常

NullPointerException - 如果一个元素是 null或者如果该数组是 null

从以下版本开始：

9