java.lang.Object

java.util.AbstractCollection <E>

java.util.AbstractList <E>

java.util.AbstractSequentialList <E>

java.util.LinkedList<E>

类型参数：: E - 此集合中元素的类型

所有已实现的接口：: Serializable , Cloneable , Iterable<E> , Collection<E> , Deque<E> , List<E> , Queue<E>

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

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

所有操作的执行都符合双向链表的预期。索引到列表中的操作将从开头或结尾遍历列表，以更接近指定索引的为准。

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

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

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

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

此类是 Java 集合框架的成员。

自从：

1.2

参见：

字段摘要

在类 java.util.AbstractList 中声明的字段
modCount
构造方法总结

构造方法

构造方法

描述

LinkedList()

构造一个空列表。

LinkedList(Collection<? extends E> c)

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

修饰符和类型

方法

描述

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

addFirst(E e)

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

void

addLast(E e)

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

void

clear()

从此list中删除所有元素。

Object

clone()

返回此 LinkedList 的浅表副本。

boolean

contains(Object o)

如果此list包含指定元素，则返回 true。

Iterator<E>

descendingIterator()

以相反的顺序返回此双端队列中元素的迭代器。

E

element()

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

E

get(int index)

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

E

getFirst()

返回此list中的第一个元素。

E

getLast()

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

int

indexOf(Object o)

返回此list中指定元素第一次出现的索引，如果此list不包含该元素，则返回 -1。

int

lastIndexOf(Object o)

返回此list中指定元素最后一次出现的索引，如果此list不包含该元素，则返回 -1。

ListIterator<E>

listIterator(int index)

返回此list中元素的列表迭代器（以适当的顺序），从列表中的指定位置开始。

boolean

offer(E e)

添加指定元素作为此list的尾部（最后一个元素）。

boolean

offerFirst(E e)

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

boolean

offerLast(E e)

在此list的末尾插入指定的元素。

E

peek()

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

E

peekFirst()

检索但不删除此list的第一个元素，如果此list为空，则返回 null。

E

peekLast()

检索但不删除此list的最后一个元素，如果此list为空，则返回 null。

E

poll()

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

E

pollFirst()

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

E

pollLast()

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

E

pop()

从此list表示的堆栈中弹出一个元素。

void

push(E e)

将一个元素推入此list表示的堆栈中。

E

remove()

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

E

remove(int index)

移除此list中指定位置的元素。

boolean

remove(Object o)

从此list中移除第一次出现的指定元素（如果存在）。

E

removeFirst()

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

boolean

removeFirstOccurrence(Object o)

删除此list中第一次出现的指定元素（从头到尾遍历列表时）。

E

removeLast()

从此list中移除并返回最后一个元素。

boolean

removeLastOccurrence(Object o)

删除此list中最后一次出现的指定元素（从头到尾遍历列表时）。

E

set(int index, E element)

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

int

size()

返回此list中的元素数。

Spliterator<E>

spliterator()

在此list中的元素上创建 late-binding 和 fail-fast Spliterator 。

Object[]

toArray()

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

<T> T[]

toArray(T[] a)

以正确的顺序（从第一个元素到最后一个元素）返回一个包含此list中所有元素的数组；返回数组的运行时类型是指定数组的类型。

在类 java.util.AbstractSequentialList 中声明的方法
iterator

在类 java.util.AbstractList 中声明的方法
equals, hashCode, listIterator, removeRange, subList

在类 java.util.AbstractCollection 中声明的方法
containsAll, isEmpty, removeAll, retainAll, toString

在类 java.lang.Object 中声明的方法
finalize, getClass, notify, notifyAll, wait, wait, wait

在接口 java.util.Collection 中声明的方法
parallelStream, removeIf, stream, toArray

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

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

在接口 java.util.List 中声明的方法
containsAll, equals, hashCode, isEmpty, iterator, listIterator, removeAll, replaceAll, retainAll, sort, subList

构造方法详细信息
- LinkedList
  
  public LinkedList()
  
  构造一个空列表。
- LinkedList
  
  public LinkedList(Collection <? extends E > c)
  
  构造一个包含指定集合元素的列表，按照集合迭代器返回元素的顺序。
  
  参数：
  
  c - 其元素要放入此list中的集合
  
  抛出：
  
  NullPointerException - 如果指定的集合为空
方法详情
- getFirst
  
  public E getFirst()
  
  返回此list中的第一个元素。
  
  指定者：
  
  getFirst 在接口 Deque<E> 中
  
  返回：
  
  此list中的第一个元素
  
  抛出：
  
  NoSuchElementException - 如果这个列表是空的
- getLast
  
  public E getLast()
  
  返回此list中的最后一个元素。
  
  指定者：
  
  getLast 在接口 Deque<E> 中
  
  返回：
  
  此list中的最后一个元素
  
  抛出：
  
  NoSuchElementException - 如果这个列表是空的
- removeFirst
  
  public E removeFirst()
  
  从此list中移除并返回第一个元素。
  
  指定者：
  
  removeFirst 在接口 Deque<E> 中
  
  返回：
  
  此list中的第一个元素
  
  抛出：
  
  NoSuchElementException - 如果这个列表是空的
- removeLast
  
  public E removeLast()
  
  从此list中移除并返回最后一个元素。
  
  指定者：
  
  removeLast 在接口 Deque<E> 中
  
  返回：
  
  此list中的最后一个元素
  
  抛出：
  
  NoSuchElementException - 如果这个列表是空的
- addFirst
  
  public void addFirst(E e)
  
  在此list的开头插入指定的元素。
  
  指定者：
  
  addFirst 在接口 Deque<E> 中
  
  参数：
  
  e - 要添加的元素
- addLast
  
  public void addLast(E e)
  
  将指定的元素附加到此list的末尾。
  此方法等效于 add(E) 。
  
  指定者：
  
  addLast 在接口 Deque<E> 中
  
  参数：
  
  e - 要添加的元素
- contains
  
  public boolean contains(Object o)
  
  如果此list包含指定元素，则返回 true。更正式地说，返回 true 当且仅当此list包含至少一个元素 e 使得 Objects.equals(o, e) 。
  
  指定者：
  
  contains 在接口 Collection<E> 中
  
  指定者：
  
  contains 在接口 Deque<E> 中
  
  指定者：
  
  contains 在接口 List<E> 中
  
  重写：
  
  contains 在类 AbstractCollection<E> 中
  
  参数：
  
  o - 要测试其在此list中是否存在的元素
  
  返回：
  
  true 如果这个列表包含指定的元素
- size
  
  public int size()
  
  返回此list中的元素数。
  
  指定者：
  
  size 在接口 Collection<E> 中
  
  指定者：
  
  size 在接口 Deque<E> 中
  
  指定者：
  
  size 在接口 List<E> 中
  
  返回：
  
  此list中的元素数
- add
  
  public boolean add(E e)
  
  将指定的元素附加到此list的末尾。
  此方法等效于 addLast(E) 。
  
  指定者：
  
  add 在接口 Collection<E> 中
  
  指定者：
  
  add 在接口 Deque<E> 中
  
  指定者：
  
  add 在接口 List<E> 中
  
  指定者：
  
  add 在接口 Queue<E> 中
  
  重写：
  
  add 在类 AbstractList<E> 中
  
  参数：
  
  e - 要附加到此list的元素
  
  返回：
  
  true（由 Collection.add(E) 指定）
- remove
  
  public boolean remove(Object o)
  
  从此list中移除第一次出现的指定元素（如果存在）。如果此list不包含该元素，则它保持不变。更正式地说，删除具有最低索引 i 的元素，这样 Objects.equals(o, get(i)) （如果存在这样的元素）。如果此list包含指定元素，则返回 true（或者等效地，如果此list因调用而更改）。
  
  指定者：
  
  remove 在接口 Collection<E> 中
  
  指定者：
  
  remove 在接口 Deque<E> 中
  
  指定者：
  
  remove 在接口 List<E> 中
  
  重写：
  
  remove 在类 AbstractCollection<E> 中
  
  参数：
  
  o - 要从此list中删除的元素（如果存在）
  
  返回：
  
  true 如果这个列表包含指定的元素
- addAll
  
  public boolean addAll(Collection <? extends E > c)
  
  按照指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到此list的末尾。如果在操作进行时修改了指定的集合，则此操作的行为是未定义的。（请注意，如果指定的集合是此list并且它是非空的，则会发生这种情况。）
  指定者：
  
  addAll 在接口 Collection<E> 中
  
  指定者：
  
  addAll 在接口 Deque<E> 中
  
  指定者：
  
  addAll 在接口 List<E> 中
  
  重写：
  
  addAll 在类 AbstractCollection<E> 中
  
  参数：
  
  c - 包含要添加到此list的元素的集合
  
  返回：
  
  true 如果此list因调用而更改
  
  抛出：
  
  NullPointerException - 如果指定的集合为空
  
  参见：
  
  AbstractCollection.add(Object)
- addAll
  
  public boolean addAll(int index, Collection <? extends E > c)
  
  将指定集合中的所有元素插入此list，从指定位置开始。将当前位于该位置的元素（如果有）和任何后续元素向右移动（增加它们的索引）。新元素将按照它们由指定集合的迭代器返回的顺序出现在列表中。
  
  指定者：
  
  addAll 在接口 List<E> 中
  
  重写：
  
  addAll 在类 AbstractSequentialList<E> 中
  
  参数：
  
  index - 从指定集合中插入第一个元素的索引
  
  c - 包含要添加到此list的元素的集合
  
  返回：
  
  true 如果此list因调用而更改
  
  抛出：
  
  IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
  
  NullPointerException - 如果指定的集合为空
- clear
  
  public void clear()
  
  从此list中删除所有元素。此调用返回后列表将为空。
  
  指定者：
  
  clear 在接口 Collection<E> 中
  
  指定者：
  
  clear 在接口 List<E> 中
  
  重写：
  
  clear 在类 AbstractList<E> 中
- get
  
  public E get(int index)
  
  返回此list中指定位置的元素。
  
  指定者：
  
  get 在接口 List<E> 中
  
  重写：
  
  get 在类 AbstractSequentialList<E> 中
  
  参数：
  
  index - 要返回的元素的索引
  
  返回：
  
  此list中指定位置的元素
  
  抛出：
  
  IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
- set
  
  public E set(int index, E element)
  
  用指定元素替换此list中指定位置的元素。
  
  指定者：
  
  set 在接口 List<E> 中
  
  重写：
  
  set 在类 AbstractSequentialList<E> 中
  
  参数：
  
  index - 要替换的元素的索引
  
  element - 要存储在指定位置的元素
  
  返回：
  
  先前在指定位置的元素
  
  抛出：
  
  IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
- add
  
  public void add(int index, E element)
  
  在此list中的指定位置插入指定元素。将当前位于该位置的元素（如果有）和任何后续元素向右移动（将其索引加一）。
  
  指定者：
  
  add 在接口 List<E> 中
  
  重写：
  
  add 在类 AbstractSequentialList<E> 中
  
  参数：
  
  index - 要插入指定元素的索引
  
  element - 要插入的元素
  
  抛出：
  
  IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
- remove
  
  public E remove(int index)
  
  移除此list中指定位置的元素。将任何后续元素向左移动（从其索引中减去一个）。返回从列表中删除的元素。
  
  指定者：
  
  remove 在接口 List<E> 中
  
  重写：
  
  remove 在类 AbstractSequentialList<E> 中
  
  参数：
  
  index - 要删除的元素的索引
  
  返回：
  
  先前在指定位置的元素
  
  抛出：
  
  IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
- indexOf
  
  public int indexOf(Object o)
  
  返回此list中指定元素第一次出现的索引，如果此list不包含该元素，则返回 -1。更正式地说，返回最低索引 i 这样 Objects.equals(o, get(i)) ，或 -1 如果没有这样的索引。
  
  指定者：
  
  indexOf 在接口 List<E> 中
  
  重写：
  
  indexOf 在类 AbstractList<E> 中
  
  参数：
  
  o - 要搜索的元素
  
  返回：
  
  此list中指定元素第一次出现的索引，如果此list不包含该元素，则为 -1
- lastIndexOf
  
  public int lastIndexOf(Object o)
  
  返回此list中指定元素最后一次出现的索引，如果此list不包含该元素，则返回 -1。更正式地说，返回最高索引 i 这样 Objects.equals(o, get(i)) ，或者 -1 如果没有这样的索引。
  
  指定者：
  
  lastIndexOf 在接口 List<E> 中
  
  重写：
  
  lastIndexOf 在类 AbstractList<E> 中
  
  参数：
  
  o - 要搜索的元素
  
  返回：
  
  此list中指定元素最后一次出现的索引，如果此list不包含该元素，则为 -1
- peek
  
  public E peek()
  
  检索但不删除此list的头部（第一个元素）。
  
  指定者：
  
  peek 在接口 Deque<E> 中
  
  指定者：
  
  peek 在接口 Queue<E> 中
  
  返回：
  
  此list的头部，如果此list为空，则为 null
  
  自从：
  
  1.5
- element
  
  public E element()
  
  检索但不删除此list的头部（第一个元素）。
  
  指定者：
  
  element 在接口 Deque<E> 中
  
  指定者：
  
  element 在接口 Queue<E> 中
  
  返回：
  
  这个列表的头部
  
  抛出：
  
  NoSuchElementException - 如果这个列表是空的
  
  自从：
  
  1.5
- poll
  
  public E poll()
  
  检索并删除此list的头部（第一个元素）。
  
  指定者：
  
  poll 在接口 Deque<E> 中
  
  指定者：
  
  poll 在接口 Queue<E> 中
  
  返回：
  
  此list的头部，如果此list为空，则为 null
  
  自从：
  
  1.5
- remove
  
  public E remove()
  
  检索并删除此list的头部（第一个元素）。
  
  指定者：
  
  remove 在接口 Deque<E> 中
  
  指定者：
  
  remove 在接口 Queue<E> 中
  
  返回：
  
  这个列表的头部
  
  抛出：
  
  NoSuchElementException - 如果这个列表是空的
  
  自从：
  
  1.5
- offer
  
  public boolean offer(E e)
  
  添加指定元素作为此list的尾部（最后一个元素）。
  
  指定者：
  
  offer 在接口 Deque<E> 中
  
  指定者：
  
  offer 在接口 Queue<E> 中
  
  参数：
  
  e - 要添加的元素
  
  返回：
  
  true（由 Queue.offer(E) 指定）
  
  自从：
  
  1.5
- offerFirst
  
  public boolean offerFirst(E e)
  
  在此list的前面插入指定的元素。
  
  指定者：
  
  offerFirst 在接口 Deque<E> 中
  
  参数：
  
  e - 要插入的元素
  
  返回：
  
  true（由 Deque.offerFirst(E) 指定）
  
  自从：
  
  1.6
- offerLast
  
  public boolean offerLast(E e)
  
  在此list的末尾插入指定的元素。
  
  指定者：
  
  offerLast 在接口 Deque<E> 中
  
  参数：
  
  e - 要插入的元素
  
  返回：
  
  true（由 Deque.offerLast(E) 指定）
  
  自从：
  
  1.6
- peekFirst
  
  public E peekFirst()
  
  检索但不删除此list的第一个元素，如果此list为空，则返回 null。
  
  指定者：
  
  peekFirst 在接口 Deque<E> 中
  
  返回：
  
  此list的第一个元素，如果此list为空，则为 null
  
  自从：
  
  1.6
- peekLast
  
  public E peekLast()
  
  检索但不删除此list的最后一个元素，如果此list为空，则返回 null。
  
  指定者：
  
  peekLast 在接口 Deque<E> 中
  
  返回：
  
  此list的最后一个元素，如果此list为空，则为 null
  
  自从：
  
  1.6
- pollFirst
  
  public E pollFirst()
  
  检索并删除此list的第一个元素，如果此list为空，则返回 null。
  
  指定者：
  
  pollFirst 在接口 Deque<E> 中
  
  返回：
  
  此list的第一个元素，如果此list为空，则为 null
  
  自从：
  
  1.6
- pollLast
  
  public E pollLast()
  
  检索并删除此list的最后一个元素，如果此list为空，则返回 null。
  
  指定者：
  
  pollLast 在接口 Deque<E> 中
  
  返回：
  
  此list的最后一个元素，如果此list为空，则为 null
  
  自从：
  
  1.6
- push
  
  public void push(E e)
  
  将一个元素推入此list表示的堆栈中。换句话说，将元素插入此list的前面。
  此方法等效于 addFirst(E) 。
  
  指定者：
  
  push 在接口 Deque<E> 中
  
  参数：
  
  e - 要推送的元素
  
  自从：
  
  1.6
- pop
  
  public E pop()
  
  从此list表示的堆栈中弹出一个元素。换句话说，删除并返回此list的第一个元素。
  此方法等效于 removeFirst() 。
  
  指定者：
  
  pop 在接口 Deque<E> 中
  
  返回：
  
  此list前面的元素（这是此list所表示的堆栈的顶部）
  
  抛出：
  
  NoSuchElementException - 如果这个列表是空的
  
  自从：
  
  1.6
- removeFirstOccurrence
  
  public boolean removeFirstOccurrence(Object o)
  
  删除此list中第一次出现的指定元素（从头到尾遍历列表时）。如果列表不包含该元素，则它不变。
  
  指定者：
  
  removeFirstOccurrence 在接口 Deque<E> 中
  
  参数：
  
  o - 要从此list中删除的元素（如果存在）
  
  返回：
  
  true 如果列表包含指定的元素
  
  自从：
  
  1.6
- removeLastOccurrence
  
  public boolean removeLastOccurrence(Object o)
  
  删除此list中最后一次出现的指定元素（从头到尾遍历列表时）。如果列表不包含该元素，则它不变。
  
  指定者：
  
  removeLastOccurrence 在接口 Deque<E> 中
  
  参数：
  
  o - 要从此list中删除的元素（如果存在）
  
  返回：
  
  true 如果列表包含指定的元素
  
  自从：
  
  1.6
- listIterator
  
  public ListIterator <E > listIterator(int index)
  
  返回此list中元素的列表迭代器（以适当的顺序），从列表中的指定位置开始。遵守 List.listIterator(int) 的总合同。
  列表迭代器是快速失败：如果列表在创建迭代器后的任何时候以任何方式进行结构修改，除了通过列表迭代器自己的 remove 或 add 方法，列表迭代器将抛出 ConcurrentModificationException 。因此，面对并发修改，迭代器会快速干净地失败，而不是冒着在未来不确定的时间出现任意的、不确定的行为的风险。
  指定者：
  
  listIterator 在接口 List<E> 中
  
  指定者：
  
  listIterator 在类 AbstractSequentialList<E> 中
  
  参数：
  
  index - 从列表迭代器返回的第一个元素的索引（通过调用 next ）
  
  返回：
  
  此list中元素的 ListIterator（按正确顺序），从列表中的指定位置开始
  
  抛出：
  
  IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())
  
  参见：
  
  List.listIterator(int)
- descendingIterator
  
  public Iterator <E > descendingIterator()
  
  从接口 Deque 复制的描述
  
  以相反的顺序返回此双端队列中元素的迭代器。元素将按从最后（尾）到第一个（头）的顺序返回。
  
  指定者：
  
  descendingIterator 在接口 Deque<E> 中
  
  返回：
  
  以相反顺序遍历此双端队列中元素的迭代器
  
  自从：
  
  1.6
- clone
  
  public Object clone()
  
  返回此 LinkedList 的浅表副本。（元素本身不会被克隆。）
  重写：
  
  clone 在类 Object 中
  
  返回：
  
  这个 LinkedList 实例的浅拷贝
  
  参见：
  
  Cloneable
- toArray
  
  public Object [] toArray()
  
  返回一个数组，其中包含此list中按正确顺序（从第一个元素到最后一个元素）的所有元素。
  返回的数组将是“安全的”，因为此list不维护对它的引用。（换句话说，这个方法必须分配一个新数组）。调用者因此可以自由修改返回的数组。
  
  此方法充当基于数组和基于集合的 API 之间的桥梁。
  指定者：
  
  toArray 在接口 Collection<E> 中
  
  指定者：
  
  toArray 在接口 List<E> 中
  
  重写：
  
  toArray 在类 AbstractCollection<E> 中
  
  返回：
  
  按正确顺序包含此list中所有元素的数组
  
  参见：
  
  Arrays.asList(Object[])
- toArray
  
  public <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> 中
  
  指定者：
  
  toArray 在接口 List<E> 中
  
  重写：
  
  toArray 在类 AbstractCollection<E> 中
  
  类型参数：
  
  T - 包含集合的数组的组件类型
  
  参数：
  
  a - 列表元素要存储到的数组，如果它足够大的话；否则，为此分配一个相同运行时类型的新数组。
  
  返回：
  
  包含列表元素的数组
  
  抛出：
  
  ArrayStoreException - 如果指定数组的运行时类型不是此list中每个元素的运行时类型的超类型
  
  NullPointerException - 如果指定数组为空
- spliterator
  
  public Spliterator <E > spliterator()
  
  在此list中的元素上创建 late-binding 和 fail-fast Spliterator 。
  Spliterator 报告 Spliterator.SIZED 和 Spliterator.ORDERED 。覆盖实施应记录附加特征值的报告。
  
  指定者：
  
  spliterator 在接口 Collection<E> 中
  
  指定者：
  
  spliterator 在接口 Iterable<E> 中
  
  指定者：
  
  spliterator 在接口 List<E> 中
  
  实现注意事项：
  
  Spliterator 还报告 Spliterator.SUBSIZED 并实现 trySplit 以允许有限的并行性。
  
  返回：
  
  a Spliterator 覆盖此list中的元素
  
  自从：
  
  1.8

类 LinkedList<E>

字段摘要

在类 java.util.AbstractList 中声明的字段

构造方法总结

方法总结

在类 java.util.AbstractSequentialList 中声明的方法

在类 java.util.AbstractList 中声明的方法

在类 java.util.AbstractCollection 中声明的方法

在类 java.lang.Object 中声明的方法

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

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

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

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

构造方法详细信息

LinkedList

LinkedList

方法详情

getFirst

getLast

removeFirst

removeLast

addFirst

addLast

contains

size

add

remove

addAll

addAll

clear

get

set

add

remove

indexOf

lastIndexOf

peek

element

poll

remove

offer

offerFirst

offerLast

peekFirst

peekLast

pollFirst

pollLast

push

pop

removeFirstOccurrence

removeLastOccurrence

listIterator

descendingIterator

clone

toArray

toArray

spliterator