Most visited

Recently visited

Results for

Added in API level 1

Summary: Inherited Fields | Ctors | Methods | Inherited Methods | [Expand All]

LinkedList

public class LinkedList
extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable

java.lang.Object
↳	java.util.AbstractCollection<E>
	↳	java.util.AbstractList<E>
		↳	java.util.AbstractSequentialList<E>
			↳	java.util.LinkedList<E>

List和Deque接口的双链表实现。实现所有可选的列表操作，并允许所有元素（包括null ）。

所有这些操作的执行情况可能与双向链表相符。索引到列表中的操作将从开始或结束遍历列表，以哪个更接近指定的索引为准。

请注意，此实现不同步。 如果多个线程同时访问链接列表，并且至少有一个线程在结构上修改列表，则它必须在外部同步。（结构修改是添加或删除一个或多个元素的任何操作;仅设置元素的值不是结构修改。）这通常是通过在自然封装列表的某个对象上进行同步来完成的。如果不存在这样的对象，则该列表应该使用Collections.synchronizedList方法“包装”。这最好在创建时完成，以防止意外的不同步访问列表：

   List list = Collections.synchronizedList(new LinkedList(...));

由这个类的iterator和listIterator方法返回的迭代器是快速失败的 ：如果在迭代器创建后的任何时候在结构上修改列表，除了通过迭代器自己的remove或add方法之外，迭代器将抛出ConcurrentModificationException 。因此，面对并发修改，迭代器快速而干净地失败，而不是在将来某个未确定的时间冒着任意的，非确定性的行为风险。

请注意，迭代器的故障快速行为无法得到保证，因为一般来说，在存在非同步并发修改的情况下不可能做出任何硬性保证。失败快速迭代器在尽力而为的基础上抛出ConcurrentModificationException 。因此，编写一个依赖于此异常的程序是正确的： 迭代器的快速失败行为应仅用于检测错误。

本课是 Java Collections Framework的成员。

也可以看看：

List
ArrayList

Summary

Inherited fields

From class java.util.AbstractList

Public constructors
`LinkedList()` 构造一个空列表。
`LinkedList(Collection<? extends E> c)` 按照集合迭代器返回的顺序构造一个包含指定集合元素的列表。

Public methods
`boolean`	`add(E e)` 将指定的元素附加到此列表的末尾。
`void`	`add(int index, E element)` 将指定的元素插入此列表中的指定位置。
`boolean`	`addAll(Collection<? extends E> c)` 按照指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到此列表的末尾。
`boolean`	`addAll(int index, Collection<? extends E> c)` 将指定集合中的所有元素插入此列表，从指定的位置开始。
`void`	`addFirst(E e)` 在此列表的开头插入指定的元素。
`void`	`addLast(E e)` 将指定的元素附加到此列表的末尾。
`void`	`clear()` 从列表中删除所有元素。
`Object`	`clone()` 返回此 `LinkedList`的浅表副本。
`boolean`	`contains(Object o)` 如果此列表包含指定的元素，则返回 `true` 。
`Iterator<E>`	`descendingIterator()` 以相反顺序返回此双端队列中元素的迭代器。
`E`	`element()` 检索但不删除此列表的头（第一个元素）。
`E`	`get(int index)` 返回此列表中指定位置的元素。
`E`	`getFirst()` 返回此列表中的第一个元素。
`E`	`getLast()` 返回此列表中的最后一个元素。
`int`	`indexOf(Object o)` 返回此列表中指定元素第一次出现的索引，如果此列表不包含元素，则返回-1。
`int`	`lastIndexOf(Object o)` 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
`ListIterator<E>`	`listIterator(int index)` 从列表中的指定位置开始，返回此列表中元素的列表迭代器（按适当顺序）。
`boolean`	`offer(E e)` 将指定的元素添加为此列表的尾部（最后一个元素）。
`boolean`	`offerFirst(E e)` 在此列表的前面插入指定的元素。
`boolean`	`offerLast(E e)` 在列表的末尾插入指定的元素。
`E`	`peek()` 检索但不删除此列表的头（第一个元素）。
`E`	`peekFirst()` 检索但不移除此列表的第一个元素，或者如果此列表为空，则返回 `null` 。
`E`	`peekLast()` 检索但不移除此列表的最后一个元素，或者如果此列表为空，则返回 `null` 。
`E`	`poll()` 检索并删除此列表的头（第一个元素）。
`E`	`pollFirst()` 检索并删除此列表的第一个元素，或者如果此列表为空，则返回 `null` 。
`E`	`pollLast()` 检索并删除此列表的最后一个元素，如果此列表为空，则返回 `null` 。
`E`	`pop()` 从该列表表示的堆栈中弹出一个元素。
`void`	`push(E e)` 将元素推入由此列表表示的堆栈。
`E`	`remove(int index)` 删除此列表中指定位置的元素。
`E`	`remove()` 检索并删除此列表的头（第一个元素）。
`boolean`	`remove(Object o)` 如果存在，则从该列表中删除指定元素的第一次出现。
`E`	`removeFirst()` 从此列表中移除并返回第一个元素。
`boolean`	`removeFirstOccurrence(Object o)` 删除此列表中首次出现的指定元素（当从头到尾遍历列表时）。
`E`	`removeLast()` 从该列表中删除并返回最后一个元素。
`boolean`	`removeLastOccurrence(Object o)` 删除此列表中指定元素的最后一次出现（当从头到尾遍历列表时）。
`E`	`set(int index, E element)` 用指定的元素替换此列表中指定位置的元素。
`int`	`size()` 返回此列表中元素的数量。
`Spliterator<E>`	`spliterator()` 通过此列表中的元素创建 late-binding和快速故障 `Spliterator` 。
`Object[]`	`toArray()` 以适当的顺序返回一个包含此列表中所有元素的数组（从第一个元素到最后一个元素）。
`<T> T[]`	`toArray(T[] a)` 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。

Inherited methods

From class java.util.AbstractSequentialList

From class java.util.AbstractList

`void`	`add(int index, E element)` 将指定元素插入此列表中的指定位置（可选操作）。这个实现总是抛出一个 `UnsupportedOperationException` 。
`boolean`	`add(E e)` 将指定的元素附加到此列表的末尾（可选操作）。
`boolean`	`addAll(int index, Collection<? extends E> c)` 将指定集合中的所有元素插入指定位置的此列表中（可选操作）。该实现获取指定集合的迭代器并对其进行迭代，并使用 `add(int, E)`将迭代器中获取的元素一次一个地插入到该列表的适当位置。
`void`	`clear()` 从此列表中删除所有元素（可选操作）。
`boolean`	`equals(Object o)` 将指定的对象与此列表进行比较以获得相等性。
`abstract E`	`get(int index)` 返回此列表中指定位置的元素。
`int`	`hashCode()` 返回此列表的哈希码值。
`int`	`indexOf(Object o)` 返回此列表中指定元素第一次出现的索引，如果此列表不包含元素，则返回-1。这个实现首先获得一个列表迭代器（带有 `listIterator()` ）。
`Iterator<E>`	`iterator()` 以适当的顺序返回此列表中元素的迭代器。
`int`	`lastIndexOf(Object o)` 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。这个实现首先获得一个列表迭代器，指向列表的末尾（带有 `listIterator(size())` ）。
`ListIterator<E>`	`listIterator(int index)` 从列表中的指定位置开始，返回此列表中元素的列表迭代器（以正确的顺序）。该实现返回 `ListIterator`接口的直接实现，该接口扩展了 `iterator()`方法返回的 `Iterator`接口的实现。
`ListIterator<E>`	`listIterator()` 返回此列表中元素的列表迭代器（按适当顺序）。该实现返回 `listIterator(0)` 。
`E`	`remove(int index)` 删除此列表中指定位置的元素（可选操作）。这个实现总是抛出一个 `UnsupportedOperationException` 。
`void`	`removeRange(int fromIndex, int toIndex)` 从列表中删除索引在 `fromIndex` （含）和 `toIndex`之间的所有元素，排他性。
`E`	`set(int index, E element)` 用指定的元素替换此列表中指定位置的元素（可选操作）。这个实现总是抛出一个 `UnsupportedOperationException` 。
`List<E>`	`subList(int fromIndex, int toIndex)` 返回指定的 `fromIndex` （包括 `fromIndex` ）和 `toIndex`之间的此列表部分视图。该实现返回一个子类为 `AbstractList`的列表。

From class java.util.AbstractCollection

`boolean`	`add(E e)` 确保此集合包含指定的元素（可选操作）。这个实现总是抛出一个 `UnsupportedOperationException` 。
`boolean`	`addAll(Collection<? extends E> c)` 将指定集合中的所有元素添加到此集合（可选操作）。该实现迭代指定的集合，并将迭代器返回的每个对象依次添加到该集合中。
`void`	`clear()` 从该集合中删除所有元素（可选操作）。该实现迭代该集合，使用 `Iterator.remove`操作删除每个元素。
`boolean`	`contains(Object o)` 如果此集合包含指定的元素，则返回 `true` 。该实现迭代集合中的元素，依次检查每个元素是否与指定元素相等。
`boolean`	`containsAll(Collection<?> c)` 如果此集合包含指定集合中的所有元素，则返回 `true` 。此实现迭代指定的集合，依次检查迭代器返回的每个元素，以查看它是否包含在此集合中。
`boolean`	`isEmpty()` 如果此集合不包含元素，则返回 `true` 。该实现返回 `size() == 0` 。
`abstract Iterator<E>`	`iterator()` 返回此集合中包含的元素的迭代器。
`boolean`	`remove(Object o)` 从该集合中移除指定元素的单个实例（如果存在）（可选操作）。该实现迭代查找指定元素的集合。
`boolean`	`removeAll(Collection<?> c)` 删除指定集合中包含的所有此集合的元素（可选操作）。该实现迭代该集合，依次检查迭代器返回的每个元素，以查看它是否包含在指定集合中。
`boolean`	`retainAll(Collection<?> c)` 仅保留包含在指定集合中的此集合中的元素（可选操作）。该实现迭代该集合，依次检查迭代器返回的每个元素，以查看它是否包含在指定集合中。
`abstract int`	`size()` 返回此集合中的元素数量。
`<T> T[]`	`toArray(T[] a)` 返回包含此集合中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。该实现返回一个数组，其中包含由该集合的迭代器以相同顺序返回的所有元素，并存储在数组的连续元素中，从索引 `0`开始。
`Object[]`	`toArray()` 返回包含此集合中所有元素的数组。该实现返回一个数组，该数组包含由该集合的迭代器返回的所有元素，按照相同的顺序存储在数组的连续元素中，从索引 `0`开始。
`String`	`toString()` 返回此集合的字符串表示形式。

From class java.lang.Object

From interface java.util.List

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

From interface java.util.Collection

`abstract boolean`	`add(E e)` 确保此集合包含指定的元素（可选操作）。
`abstract boolean`	`addAll(Collection<? extends E> c)` 将指定集合中的所有元素添加到此集合（可选操作）。
`abstract void`	`clear()` 从该集合中删除所有元素（可选操作）。
`abstract boolean`	`contains(Object o)` 如果此集合包含指定的元素，则返回 `true` 。
`abstract boolean`	`containsAll(Collection<?> c)` 如果此集合包含指定集合中的所有元素，则返回 `true` 。
`abstract boolean`	`equals(Object o)` 将指定的对象与此集合进行比较以获得相等性。
`abstract int`	`hashCode()` 返回此集合的哈希码值。
`abstract boolean`	`isEmpty()` 如果此集合不包含元素，则返回 `true` 。
`abstract Iterator<E>`	`iterator()` 返回此集合中元素的迭代器。
`default Stream<E>`	`parallelStream()` 返回一个可能与此集合并行的 `Stream`作为其源。
`abstract boolean`	`remove(Object o)` 从该集合中移除指定元素的单个实例（如果存在）（可选操作）。
`abstract boolean`	`removeAll(Collection<?> c)` 删除指定集合中包含的所有此集合的元素（可选操作）。
`default boolean`	`removeIf(Predicate<? super E> filter)` 删除此集合中满足给定谓词的所有元素。
`abstract boolean`	`retainAll(Collection<?> c)` 仅保留包含在指定集合中的此集合中的元素（可选操作）。
`abstract int`	`size()` 返回此集合中的元素数量。
`default Spliterator<E>`	`spliterator()` 在此集合中的元素上创建一个 `Spliterator` 。
`default Stream<E>`	`stream()` 以此集合作为源返回顺序 `Stream` 。
`abstract <T> T[]`	`toArray(T[] a)` 返回包含此集合中所有元素的数组; 返回数组的运行时类型是指定数组的运行时类型。
`abstract Object[]`	`toArray()` 返回包含此集合中所有元素的数组。

From interface java.util.Deque

`abstract boolean`	`add(E e)` 将指定的元素插入此双端队列表示的队列中（换句话说，在此双端队列的尾部），如果它是立即可行且不会违反容量限制，返回 `true`成功时和抛出 `IllegalStateException` ，如果当前没有空间可用的。
`abstract void`	`addFirst(E e)` 如果可以立即执行而不违反容量限制，则将指定元素插入此双端队列的前端，如果当前没有可用空间，则抛出 `IllegalStateException` 。
`abstract void`	`addLast(E e)` 如果可以立即执行而不违反容量限制，则在此双端队列的末尾插入指定的元素，如果当前没有可用空间，则抛出 `IllegalStateException` 。
`abstract boolean`	`contains(Object o)` 如果此双端队列包含指定的元素，则返回 `true` 。
`abstract Iterator<E>`	`descendingIterator()` 以相反顺序返回此双端队列中元素的迭代器。
`abstract E`	`element()` 检索但不删除由此双端队列表示的队列头（换句话说，此双端队列的第一个元素）。
`abstract E`	`getFirst()` 检索但不删除此双端队列的第一个元素。
`abstract E`	`getLast()` 检索但不删除此双端队列的最后一个元素。
`abstract Iterator<E>`	`iterator()` 以适当的顺序返回此双端队列中元素的迭代器。
`abstract boolean`	`offer(E e)` 将指定的元素插入此双端队列表示的队列中（换句话说，在此双端队列的尾部），如果它是立即可行且不会违反容量限制，返回 `true`在成功和 `false` ，如果当前没有空间可用。
`abstract boolean`	`offerFirst(E e)` 将指定的元素插入此双端队列的前端，除非它违反了容量限制。
`abstract boolean`	`offerLast(E e)` 在该双端队列的末尾插入指定的元素，除非它违反了容量限制。
`abstract E`	`peek()` 检索但不移除由此双端队列表示的队列头（换句话说，此双端队列的第一个元素），或者如果此双端队列为空，则返回 `null` 。
`abstract E`	`peekFirst()` 检索但不删除此双端队列的第一个元素，或者如果此双端队列为空，则返回 `null` 。
`abstract E`	`peekLast()` 检索但不移除此双端队列的最后一个元素，或者如果此双端队列为空，则返回 `null` 。
`abstract E`	`poll()` 检索并删除由此双端队列表示的队列头（换句话说，此双端队列的第一个元素）;如果此双端队列为空，则返回 `null` 。
`abstract E`	`pollFirst()` 检索并移除此双端队列的第一个元素，或者如果此双端队列为空，则返回 `null` 。
`abstract E`	`pollLast()` 检索并移除此双端队列的最后一个元素，或者如果此双端队列为空，则返回 `null` 。
`abstract E`	`pop()` 从由此双端队列表示的堆栈中弹出一个元素。
`abstract void`	`push(E e)` 如果可以立即执行而不违反容量限制， `IllegalStateException`元素推入由此双端队列表示的堆栈（即，在此双端队列的头部），如果当前没有可用空间，则抛出 `IllegalStateException` 。
`abstract E`	`remove()` 检索并移除由此双端队列表示的队列头（换句话说，此双端队列的第一个元素）。
`abstract boolean`	`remove(Object o)` 从此双端队列中移除指定元素的第一个匹配项。
`abstract E`	`removeFirst()` 检索并删除此双端队列的第一个元素。
`abstract boolean`	`removeFirstOccurrence(Object o)` 从此双端队列中移除指定元素的第一个匹配项。
`abstract E`	`removeLast()` 检索并删除此双端队列的最后一个元素。
`abstract boolean`	`removeLastOccurrence(Object o)` 从此双端队列中移除指定元素的最后一次出现。
`abstract int`	`size()` 返回此双端队列中的元素数量。

From interface java.lang.Iterable

From interface java.util.Queue

Public constructors

LinkedList

Added in API level 1

LinkedList ()

构造一个空列表。

LinkedList

Added in API level 1

LinkedList (Collection<? extends E> c)

按照集合迭代器返回的顺序构造一个包含指定集合元素的列表。

Parameters
`c`	`Collection`: the collection whose elements are to be placed into this list

Throws
`NullPointerException`	if the specified collection is null

Public methods

add

Added in API level 1

boolean add (E e)

将指定的元素附加到此列表的末尾。

该方法相当于 addLast(E) 。

Parameters
`e`	`E`: element to be appended to this list

Returns
`boolean`	`true` (as specified by `add(E)`)

add

Added in API level 1

void add (int index, 
                E element)

将指定的元素插入此列表中的指定位置。将当前位置的元素（如果有的话）和任何后续元素移到右侧（将其中的一个添加到它们的索引）。

Parameters
`index`	`int`: index at which the specified element is to be inserted
`element`	`E`: element to be inserted

Throws
`IndexOutOfBoundsException`

addAll

Added in API level 1

boolean addAll (Collection<? extends E> c)

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

Parameters
`c`	`Collection`: collection containing elements to be added to this list

Returns
`boolean`	`true` if this list changed as a result of the call

Throws
`NullPointerException`	if the specified collection is null

addAll

Added in API level 1

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

将指定集合中的所有元素插入此列表，从指定的位置开始。将当前在该位置的元素（如果有的话）和随后的元素移到右侧（增加它们的索引）。新元素将按照它们由指定集合的迭代器返回的顺序出现在列表中。

Parameters
`index`	`int`: index at which to insert the first element from the specified collection
`c`	`Collection`: collection containing elements to be added to this list

Returns
`boolean`	`true` if this list changed as a result of the call

Throws
`IndexOutOfBoundsException`
`NullPointerException`	if the specified collection is null

addFirst

Added in API level 1

void addFirst (E e)

在此列表的开头插入指定的元素。

Parameters
`e`	`E`: the element to add

addLast

Added in API level 1

void addLast (E e)

将指定的元素附加到此列表的末尾。

该方法相当于 add(E) 。

Parameters
`e`	`E`: the element to add

clear

Added in API level 1

void clear ()

从列表中删除所有元素。此通话返回后，该列表将为空。

clone

Added in API level 1

Object clone ()

返回此LinkedList的浅表副本。（元素本身没有被克隆。）

Returns
`Object`	a shallow copy of this `LinkedList` instance

contains

Added in API level 1

boolean contains (Object o)

如果此列表包含指定的元素，则返回true 。更正式地，返回true当且仅当该列表包含至少一个元素e例如(o==null ? e==null : o.equals(e)) 。

Parameters
`o`	`Object`: element whose presence in this list is to be tested

Returns
`boolean`	`true` if this list contains the specified element

descendingIterator

Added in API level 9

Iterator<E> descendingIterator ()

以相反顺序返回此双端队列中元素的迭代器。元素将从上一个（尾）到第一个（头）的顺序返回。

Returns
`Iterator<E>`	an iterator over the elements in this deque in reverse sequence

element

Added in API level 1

E element ()

检索但不删除此列表的头（第一个元素）。

Returns
`E`	the head of this list

Throws
`NoSuchElementException`	if this list is empty

get

Added in API level 1

E get (int index)

返回此列表中指定位置的元素。

Parameters
`index`	`int`: index of the element to return

Returns
`E`	the element at the specified position in this list

Throws
`IndexOutOfBoundsException`

getFirst

Added in API level 1

E getFirst ()

返回此列表中的第一个元素。

Returns
`E`	the first element in this list

Throws
`NoSuchElementException`	if this list is empty

getLast

Added in API level 1

E getLast ()

返回此列表中的最后一个元素。

Returns
`E`	the last element in this list

Throws
`NoSuchElementException`	if this list is empty

indexOf

Added in API level 1

int indexOf (Object o)

返回此列表中指定元素第一次出现的索引，如果此列表不包含元素，则返回-1。更正式地说，返回最低索引i例如(o==null ? get(i)==null : o.equals(get(i))) ，如果没有这样的索引，则返回-1。

Parameters
`o`	`Object`: element to search for

Returns
`int`	the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element

lastIndexOf

Added in API level 1

int lastIndexOf (Object o)

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

Parameters
`o`	`Object`: element to search for

Returns
`int`	the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element

listIterator

Added in API level 1

ListIterator<E> listIterator (int index)

从列表中的指定位置开始，返回此列表中元素的列表迭代器（按适当顺序）。遵守List.listIterator(int)的总合同。

列表迭代器是快速失败的 ：如果列表在迭代器创建后的任何时候在结构上被修改，除了通过列表迭代器自己的remove或add方法之外，列表迭代器将抛出ConcurrentModificationException 。因此，面对并发修改，迭代器快速而干净地失败，而不是在将来某个未确定的时间冒着任意的，非确定性的行为风险。

Parameters
`index`	`int`: index of the first element to be returned from the list-iterator (by a call to `next`)

Returns
`ListIterator<E>`	a ListIterator of the elements in this list (in proper sequence), starting at the specified position in the list

Throws
`IndexOutOfBoundsException`

也可以看看：

listIterator(int)

offer

Added in API level 1

boolean offer (E e)

将指定的元素添加为此列表的尾部（最后一个元素）。

Parameters
`e`	`E`: the element to add

Returns
`boolean`	`true` (as specified by `offer(E)`)

offerFirst

Added in API level 9

boolean offerFirst (E e)

在此列表的前面插入指定的元素。

Parameters
`e`	`E`: the element to insert

Returns
`boolean`	`true` (as specified by `offerFirst(E)`)

offerLast

Added in API level 9

boolean offerLast (E e)

在列表的末尾插入指定的元素。

Parameters
`e`	`E`: the element to insert

Returns
`boolean`	`true` (as specified by `offerLast(E)`)

peek

Added in API level 1

E peek ()

检索但不删除此列表的头（第一个元素）。

Returns
`E`	the head of this list, or `null` if this list is empty

peekFirst

Added in API level 9

E peekFirst ()

检索但不移除此列表的第一个元素，或者如果此列表为空，则返回 null 。

Returns
`E`	the first element of this list, or `null` if this list is empty

peekLast

Added in API level 9

E peekLast ()

检索但不移除此列表的最后一个元素，或者如果此列表为空，则返回 null 。

Returns
`E`	the last element of this list, or `null` if this list is empty

poll

Added in API level 1

E poll ()

检索并删除此列表的头（第一个元素）。

Returns
`E`	the head of this list, or `null` if this list is empty

pollFirst

Added in API level 9

E pollFirst ()

检索并删除此列表的第一个元素，或者如果此列表为空，则返回 null 。

Returns
`E`	the first element of this list, or `null` if this list is empty

pollLast

Added in API level 9

E pollLast ()

检索并删除此列表的最后一个元素，如果此列表为空，则返回 null 。

Returns
`E`	the last element of this list, or `null` if this list is empty

pop

Added in API level 9

E pop ()

从该列表表示的堆栈中弹出一个元素。换句话说，删除并返回此列表的第一个元素。

该方法相当于 removeFirst() 。

Returns
`E`	the element at the front of this list (which is the top of the stack represented by this list)

Throws
`NoSuchElementException`	if this list is empty

push

Added in API level 9

void push (E e)

将元素推入由此列表表示的堆栈。换句话说，将该元素插入此列表的前面。

此方法相当于 addFirst(E) 。

Parameters
`e`	`E`: the element to push

remove

Added in API level 1

E remove (int index)

删除此列表中指定位置的元素。将任何随后的元素向左移（从其索引中减去一个元素）。返回从列表中移除的元素。

Parameters
`index`	`int`: the index of the element to be removed

Returns
`E`	the element previously at the specified position

Throws
`IndexOutOfBoundsException`

remove

Added in API level 1

E remove ()

检索并删除此列表的头（第一个元素）。

Returns
`E`	the head of this list

Throws
`NoSuchElementException`	if this list is empty

remove

Added in API level 1

boolean remove (Object o)

如果存在，则从该列表中删除指定元素的第一次出现。如果该列表不包含该元素，则不变。更正式地说，删除索引最小的元素i ，使得(o==null ? get(i)==null : o.equals(get(i))) （如果存在这样的元素）。如果此列表包含指定的元素（或者等价地，如果此列表因呼叫而改变），则返回true 。

Parameters
`o`	`Object`: element to be removed from this list, if present

Returns
`boolean`	`true` if this list contained the specified element

removeFirst

Added in API level 1

E removeFirst ()

从此列表中移除并返回第一个元素。

Returns
`E`	the first element from this list

Throws
`NoSuchElementException`	if this list is empty

removeFirstOccurrence

Added in API level 9

boolean removeFirstOccurrence (Object o)

删除此列表中首次出现的指定元素（当从头到尾遍历列表时）。如果该列表不包含该元素，则不变。

Parameters
`o`	`Object`: element to be removed from this list, if present

Returns
`boolean`	`true` if the list contained the specified element

removeLast

Added in API level 1

E removeLast ()

从该列表中删除并返回最后一个元素。

Returns
`E`	the last element from this list

Throws
`NoSuchElementException`	if this list is empty

removeLastOccurrence

Added in API level 9

boolean removeLastOccurrence (Object o)

删除此列表中指定元素的最后一次出现（当从头到尾遍历列表时）。如果该列表不包含该元素，则不变。

Parameters
`o`	`Object`: element to be removed from this list, if present

Returns
`boolean`	`true` if the list contained the specified element

set

Added in API level 1

E set (int index, 
                E element)

用指定的元素替换此列表中指定位置的元素。

Parameters
`index`	`int`: index of the element to replace
`element`	`E`: element to be stored at the specified position

Returns
`E`	the element previously at the specified position

Throws
`IndexOutOfBoundsException`

size

Added in API level 1

int size ()

返回此列表中元素的数量。

Returns
`int`	the number of elements in this list

spliterator

Added in API level 24

Spliterator<E> spliterator ()

在此列表中的元素上创建 late-binding和 快速故障 Spliterator 。

Spliterator报告SIZED和ORDERED 。重写实现应记录附加特征值的报告。

Implementation Note:

The Spliterator additionally reports SUBSIZED and implements trySplit to permit limited parallelism..

Returns
`Spliterator<E>`	a `Spliterator` over the elements in this list

toArray

Added in API level 1

Object[] toArray ()

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

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

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

Returns
`Object[]`	an array containing all of the elements in this list in proper sequence

toArray

Added in API level 1

T[] toArray (T[] a)

以正确的顺序返回一个包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。如果列表符合指定的数组，则返回其中。否则，将使用指定数组的运行时类型和此列表的大小分配一个新数组。

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

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

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

     String[] y = x.toArray(new String[0]);

Note that toArray(new Object[0]) is identical in function to toArray().

Parameters
`a`	`T`: the array into which the elements of the list are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose.

Returns
`T[]`	an array containing the elements of the list

Throws
`ArrayStoreException`	if the runtime type of the specified array is not a supertype of the runtime type of every element in this list
`NullPointerException`	if the specified array is null