Module java.base

Package java.util

Class LinkedList<E>

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>, SequencedCollection<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

参见:

• List
• ArrayList
• 序列化形式

Field Summary

Fields declared in class java.util.AbstractList

modCount

Constructor Summary

Constructors

Constructor	Description
LinkedList()	构造一个空列表。
LinkedList(Collection<? extends E> c)	构造一个包含指定集合中元素的列表，顺序与集合的迭代器返回的顺序相同。

Method Summary

Modifier and Type	Method	Description
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	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()	检索并移除此列表的头部（第一个元素）。
E	remove(int index)	移除此列表中指定位置的元素。
boolean	remove(Object o)	从此列表中移除指定元素的第一次出现（如果存在）。
E	removeFirst()	移除并返回此列表的第一个元素。
boolean	removeFirstOccurrence(Object o)	从此列表中移除指定元素的第一次出现（从头到尾遍历列表时）。
E	removeLast()	移除并返回此列表的最后一个元素。
boolean	removeLastOccurrence(Object o)	从此列表中移除指定元素的最后一次出现（从头到尾遍历列表时）。
LinkedList<E>	reversed()	返回此集合的逆序视图。
E	set(int index, E element)	用指定元素替换此列表中指定位置的元素。
int	size()	返回此列表中的元素数。
Spliterator<E>	spliterator()	创建一个延迟绑定和快速失败的此列表中元素的Spliterator。
Object[]	toArray()	返回一个数组，其中包含此列表中所有元素的顺序（从第一个到最后一个元素）。
<T> T[]	toArray(T[] a)	返回一个数组，其中包含此列表中所有元素的顺序（从第一个到最后一个元素）；返回数组的运行时类型是指定数组的类型。

Methods declared in class java.util.AbstractSequentialList

iterator

Methods declared in class java.util.AbstractList

equals, hashCode, listIterator, removeRange, subList

Methods declared in class java.util.AbstractCollection

containsAll, isEmpty, removeAll, retainAll, toString

Methods declared in class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods declared in interface java.util.Collection

parallelStream, removeIf, stream, toArray

Methods declared in interface java.util.Deque

iterator

Methods declared in interface java.lang.Iterable

forEach

Methods declared in interface java.util.List

containsAll, equals, hashCode, isEmpty, iterator, listIterator, removeAll, replaceAll, retainAll, sort, subList

Constructor Details

LinkedList

             public LinkedList()
            

构造一个空列表。

LinkedList

             public LinkedList(Collection<? extends E> c)
            

构造一个包含指定集合中元素的列表，顺序与集合的迭代器返回的顺序相同。

参数:

c - 要放入此列表中的元素的集合

抛出:

NullPointerException - 如果指定的集合为null

Method Details

getFirst

             public E getFirst()
            

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

指定者:

getFirst 在接口 Deque<E>中

指定者:

getFirst 在接口 List<E>中

指定者:

getFirst 在接口 SequencedCollection<E>中

返回:

此列表中的第一个元素

抛出:

NoSuchElementException - 如果此列表为空

getLast

             public E getLast()
            

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

指定者:

getLast 在接口 Deque<E>中

指定者:

getLast 在接口 List<E>中

指定者:

getLast 在接口 SequencedCollection<E>中

返回:

此列表中的最后一个元素

抛出:

NoSuchElementException - 如果此列表为空

removeFirst

             public E removeFirst()
            

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

指定由：

removeFirst 在接口 Deque<E>中

指定由：

removeFirst 在接口 List<E>中

指定由：

removeFirst 在接口 SequencedCollection<E>中

返回：

此列表中的第一个元素

抛出：

NoSuchElementException - 如果此列表为空

removeLast

             public E removeLast()
            

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

指定由：

removeLast 在接口 Deque<E>中

指定由：

removeLast 在接口 List<E>中

指定由：

removeLast 在接口 SequencedCollection<E>中

返回：

此列表中的最后一个元素

抛出：

NoSuchElementException - 如果此列表为空

addFirst

             public void addFirst(E e)
            

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

指定由：

addFirst 在接口 Deque<E>中

指定由：

addFirst 在接口 List<E>中

指定由：

addFirst 在接口 SequencedCollection<E>中

参数：

e - 要添加的元素

addLast

             public void addLast(E e)
            

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

此方法等效于add(E)。

指定由：

addLast 在接口 Deque<E>中

指定由：

addLast 在接口 List<E>中

指定由：

addLast 在接口 SequencedCollection<E>中

参数：

e - 要添加的元素

contains

             public boolean contains(Object o)
            

如果此列表包含指定的元素，则返回true。更正式地说，如果此列表包含至少一个元素e，使得Objects.equals(o, e)，则返回true。

指定由：

contains 在接口 Collection<E>中

指定由：

contains 在接口 Deque<E>中

指定由：

contains 在接口 List<E>中

覆盖：

contains 在类 AbstractCollection<E>中

参数：

o - 要测试其在此列表中存在性的元素

返回：

如果此列表包含指定的元素，则返回true

size

             public int size()
            

返回此列表中的元素数。

指定由：

size 在接口 Collection<E>中

指定由：

size 在接口 Deque<E>中

指定由：

size 在接口 List<E>中

返回：

此列表中的元素数

add

             public boolean add(E e)
            

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

此方法等效于addLast(E)。

指定由：

add 在接口 Collection<E>中

指定由：

add 在接口 Deque<E>中

指定由：

add 在接口 List<E>中

指定由：

add 在接口 Queue<E>中

覆盖：

add 在类 AbstractList<E>中

参数：

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

返回：

true（如Collection.add(E)所指定）

remove

             public boolean remove(Object o)
            

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

指定由：

remove 在接口 Collection<E>中

指定由：

remove 在接口 Deque<E>中

指定由：

remove 在接口 List<E>中

覆盖：

remove 在类 AbstractCollection<E>中

参数：

o - 如果存在，则从此列表中删除的元素

返回：

如果此列表包含指定的元素，则返回true

addAll

             public boolean addAll(Collection<? extends E> c)
            

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

指定者:

addAll 在接口 Collection<E>中

指定者:

addAll 在接口 Deque<E>中

指定者:

addAll 在接口 List<E>中

覆盖:

addAll 在类 AbstractCollection<E>中

参数:

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

返回值:

true 如果此列表因调用而更改

抛出:

NullPointerException - 如果指定的集合为null

参见:

• AbstractCollection.add(Object)

addAll

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

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

指定者:

addAll 在接口 List<E>中

覆盖:

addAll 在类 AbstractSequentialList<E>中

参数:

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

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

返回值:

true 如果此列表因调用而更改

抛出:

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

NullPointerException - 如果指定的集合为null

clear

             public void clear()
            

从此列表中删除所有元素。此调用返回后，列表将为空。

指定者:

clear 在接口 Collection<E>中

指定者:

clear 在接口 List<E>中

覆盖:

clear 在类 AbstractList<E>中

get

             public E get(int index)
            

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

指定者:

get 在接口 List<E>中

覆盖:

get 在类 AbstractSequentialList<E>中

参数:

index - 要返回的元素的索引

返回值:

此列表中指定位置的元素

抛出:

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

set

             public E set(int index, E element)
            

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

指定者:

set 在接口 List<E>中

覆盖:

set 在类 AbstractSequentialList<E>中

参数:

index - 要替换的元素的索引

element - 要存储在指定位置的元素

返回值:

先前在指定位置的元素

抛出:

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

add

             public void add(int index, E element)
            

在此列表中指定位置插入指定元素。将当前在该位置的元素（如果有）和任何后续元素向右移动（将它们的索引加一）。

指定者:

add 在接口 List<E>中

覆盖:

add 在类 AbstractSequentialList<E>中

参数:

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

element - 要插入的元素

抛出:

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

remove

             public E remove(int index)
            

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

指定者:

remove 在接口 List<E>中

覆盖:

remove 在类 AbstractSequentialList<E>中

参数:

index - 要删除的元素的索引

返回值:

先前在指定位置的元素

抛出:

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

indexOf

             public int indexOf(Object o)
            

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

指定者:

indexOf 在接口 List<E>中

覆盖:

indexOf 在类 AbstractList<E>中

参数:

o - 要搜索的元素

返回值:

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

lastIndexOf

             public int lastIndexOf(Object o)
            

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

指定者:

lastIndexOf 在接口 List<E>中

覆盖:

lastIndexOf 在类 AbstractList<E>中

参数:

o - 要搜索的元素

返回值:

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

peek

             public E peek()
            

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

指定由：

peek 在接口 Deque<E>中

指定由：

peek 在接口 Queue<E>中

返回：

此列表的头部，如果此列表为空则返回null

自：

1.5

element

             public E element()
            

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

指定由：

element 在接口 Deque<E>中

指定由：

element 在接口 Queue<E>中

返回：

此列表的头部

抛出：

NoSuchElementException - 如果此列表为空

自：

1.5

poll

             public E poll()
            

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

指定由：

poll 在接口 Deque<E>中

指定由：

poll 在接口 Queue<E>中

返回：

此列表的头部，如果此列表为空则返回null

自：

1.5

remove

             public E remove()
            

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

指定由：

remove 在接口 Deque<E>中

指定由：

remove 在接口 Queue<E>中

返回：

此列表的头部

抛出：

NoSuchElementException - 如果此列表为空

自：

1.5

offer

             public boolean offer(E e)
            

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

指定由：

offer 在接口 Deque<E>中

指定由：

offer 在接口 Queue<E>中

参数：

e - 要添加的元素

返回：

true（如Queue.offer(E)所指定）

自：

1.5

offerFirst

             public boolean offerFirst(E e)
            

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

指定由：

offerFirst 在接口 Deque<E>中

参数：

e - 要插入的元素

返回：

true（如Deque.offerFirst(E)所指定）

自：

1.6

offerLast

             public boolean offerLast(E e)
            

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

指定由：

offerLast 在接口 Deque<E>中

参数：

e - 要插入的元素

返回：

true（如Deque.offerLast(E)所指定）

自：

1.6

peekFirst

             public E peekFirst()
            

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

指定由：

peekFirst 在接口 Deque<E>中

返回：

此列表的第一个元素，如果此列表为空则返回null

自：

1.6

peekLast

             public E peekLast()
            

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

指定由：

peekLast 在接口 Deque<E>中

返回：

此列表的最后一个元素，如果此列表为空则返回null

自：

1.6

pollFirst

             public E pollFirst()
            

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

指定由：

pollFirst 在接口 Deque<E>中

返回：

此列表的第一个元素，如果此列表为空则返回null

自：

1.6

pollLast

             public E pollLast()
            

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

指定由：

pollLast 在接口 Deque<E>中

返回：

此列表的最后一个元素，如果此列表为空则返回null

自：

1.6

push

             public void push(E e)
            

将指定的元素推送到此列表表示的堆栈。换句话说，在此列表的前面插入元素。

此方法等效于addFirst(E)。

指定由：

push 在接口 Deque<E>中

参数：

e - 要推送的元素

自：

1.6

pop

             public E pop()
            

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

此方法等效于removeFirst()。

指定由：

pop 在接口 Deque<E>中

返回：

此列表的前面的元素（即此列表表示的堆栈的顶部）

抛出：

NoSuchElementException - 如果此列表为空

自：

1.6

removeFirstOccurrence

             public boolean removeFirstOccurrence(Object o)
            

从此列表中移除指定元素的第一个出现（从头到尾遍历列表）。如果列表不包含该元素，则列表保持不变。

指定由：

removeFirstOccurrence 在接口 Deque<E>中

参数：

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

返回：

true 如果列表包含指定元素

自：

1.6

removeLastOccurrence

             public boolean removeLastOccurrence(Object o)
            

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

指定由：

removeLastOccurrence 在接口 Deque<E>中

参数：

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

返回：

true 如果列表包含指定元素

自：

1.6

listIterator

             public ListIterator<E> listIterator(int index)
            

返回此列表中元素的列表迭代器（按正确顺序），从列表中指定位置开始。遵守List.listIterator(int)的一般约定。

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

指定由：

listIterator 在接口 List<E>中

指定由：

listIterator 在类 AbstractSequentialList<E>中

参数：

index - 从列表迭代器中返回的第一个元素的索引（通过调用next）

返回：

返回此列表中元素的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()
            

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

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

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

指定由：

toArray 在接口 Collection<E>中

指定由：

toArray 在接口 List<E>中

覆盖：

toArray 在类 AbstractCollection<E>中

返回：

返回一个包含此列表中所有元素的数组，按照正确顺序

参见：

• Arrays.asList(Object[])

toArray

             public <T> T[] toArray(T[] a)
            

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

如果列表适合于指定数组并有多余空间（即，数组的元素多于列表），则紧接列表末尾的数组元素将设置为null。（这在仅当调用者知道列表不包含任何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 - 如果指定数组的运行时类型不是此列表中每个元素的运行时类型的超类型

NullPointerException - 如果指定数组为null

spliterator

             public Spliterator<E> spliterator()
            

创建一个延迟绑定和快速失败的Spliterator，用于遍历此列表中的元素。

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

指定由：

spliterator 在接口 Collection<E>中

指定由：

spliterator 在接口 Iterable<E>中

指定由：

spliterator 在接口 List<E>中

实现说明：

Spliterator另外报告Spliterator.SUBSIZED并实现trySplit以允许有限的并行性。

返回：

此列表中元素的Spliterator

自：

1.8

reversed

             public LinkedList<E> reversed()
            

返回此集合的逆序view。返回视图中元素的遇到顺序与此集合中元素的遇到顺序相反。逆序排序会影响所有对顺序敏感的操作，包括对返回视图的集合的操作。如果集合实现允许修改此视图，则对此视图的修改会“写入”到基础集合。对逆序视图的更改可能会传播到此列表。此外，对此列表的更改将在逆序视图中可见。

指定由：

reversed 在接口 Deque<E>中

指定由：

reversed 在接口 List<E>中

指定由：

reversed 在接口 SequencedCollection<E>中

返回：

作为List的此集合的逆序view

自：

21