模块  java.base
软件包  java.util

Class 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方法返回的迭代器是快速失败的 ：如果在创建迭代器之后的任何时候对列表进行结构修改，除了通过Iterator自己的remove或add方法之外，迭代器将抛出ConcurrentModificationException 。 因此，在并发修改的情况下，迭代器快速而干净地失败，而不是在未来的未确定时间冒任意，非确定性行为的风险。

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

    此类是Java Collections Framework的成员。

    从以下版本开始：
    1.2
    另请参见：
    List ， ArrayList ， Serialized Form

    • 构造方法摘要

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

    • 方法摘要

      所有方法  实例方法 具体的方法 
      变量和类型 方法 描述
      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)
      删除此列表中最后一次出现的指定元素（从头到尾遍历列表时）。
      E set​(int index, E element)
      用指定的元素替换此列表中指定位置的元素。
      int size()
      返回此列表中的元素数。
      Spliterator<E> spliterator()
      在此列表中的元素上创建late-binding和故障快速 Spliterator 。
      Object[] toArray()
      以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。
      <T> T[] toArray​(T[] a)
      以适当的顺序返回包含此列表中所有元素的数组（从第一个元素到最后一个元素）; 返回数组的运行时类型是指定数组的运行时类型。

    • 构造方法详细信息

      • LinkedList

        public LinkedList()
        构造一个空列表。

      • LinkedList

        public LinkedList​(Collection<? extends E> c)
        按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。
        参数
        c - c其元素放入此列表的集合
        异常
        NullPointerException - 如果指定的集合为null

    • 方法详细信息

      • getFirst

        public E getFirst()
        返回此列表中的第一个元素。
        Specified by:
        getFirst在界面 Deque<E>
        结果
        此列表中的第一个元素
        异常
        NoSuchElementException - 如果此列表为空

      • getLast

        public E getLast()
        返回此列表中的最后一个元素。
        Specified by:
        getLast在界面 Deque<E>
        结果
        此列表中的最后一个元素
        异常
        NoSuchElementException - 如果此列表为空

      • removeFirst

        public E removeFirst()
        从此列表中删除并返回第一个元素。
        Specified by:
        removeFirst in interface Deque<E>
        结果
        此列表中的第一个元素
        异常
        NoSuchElementException - 如果此列表为空

      • removeLast

        public E removeLast()
        从此列表中删除并返回最后一个元素。
        Specified by:
        removeLast在界面 Deque<E>
        结果
        此列表中的最后一个元素
        异常
        NoSuchElementException - 如果此列表为空

      • addFirst

        public void addFirst​(E e)
        在此列表的开头插入指定的元素。
        Specified by:
        addFirst in interface Deque<E>
        参数
        e - 要添加的元素

      • addLast

        public void addLast​(E e)
        将指定的元素追加到此列表的末尾。

        此方法相当于add(E) 。

        Specified by:
        addLast接口 Deque<E>
        参数
        e - 要添加的元素

      • contains

        public boolean contains​(Object o)
        如果此列表包含指定的元素，则返回true 。 更正式地说，返回true当且仅当此列表包含至少一个元素e ，使得Objects.equals(o, e) 。
        Specified by:
        contains in interface Collection<E>
        Specified by:
        contains在界面 Deque<E>
        Specified by:
        contains在界面 List<E>
        重写：
        contains类 AbstractCollection<E>
        参数
        o - 要测试其在此列表中的元素
        结果
        true如果此列表包含指定的元素

      • size

        public int size()
        返回此列表中的元素数。
        Specified by:
        size在界面 Collection<E>
        Specified by:
        size在界面 Deque<E>
        Specified by:
        size在界面 List<E>
        结果
        此列表中的元素数量

      • remove

        public boolean remove​(Object o)
        从该列表中删除指定元素的第一个匹配项（如果存在）。 如果此列表不包含该元素，则不会更改。 更正式地，删除具有最低索引i的元素，使得Objects.equals(o, get(i)) （如果存在这样的元素）。 如果此列表包含指定的元素，则返回true （或等效地，如果此列表因调用而更改）。
        Specified by:
        remove在界面 Collection<E>
        Specified by:
        remove在界面 Deque<E>
        Specified by:
        remove在界面 List<E>
        重写：
        remove在类 AbstractCollection<E>
        参数
        o - 要从此列表中删除的元素（如果存在）
        结果
        true如果此列表包含指定的元素

      • addAll

        public boolean addAll​(Collection<? extends E> c)
        将指定集合中的所有元素按指定集合的迭代器返回的顺序附加到此列表的末尾。 如果在操作正在进行时修改了指定的集合，则此操作的行为是不确定的。 （请注意，如果指定的集合是此列表，则会发生这种情况，并且它是非空的。）
        Specified by:
        addAll在界面 Collection<E>
        Specified by:
        addAll在界面 Deque<E>
        Specified by:
        addAll在界面 List<E>
        重写：
        addAll在类 AbstractCollection<E>
        参数
        c - 包含要添加到此列表的元素的集合
        结果
        true如果此列表因呼叫而更改
        异常
        NullPointerException - 如果指定的集合为null
        另请参见：
        AbstractCollection.add(Object)

      • addAll

        public boolean addAll​(int index,                      Collection<? extends E> c)
        从指定位置开始，将指定集合中的所有元素插入此列表。 将当前位置的元素（如果有）和任何后续元素向右移动（增加其索引）。 新元素将按照指定集合的迭代器返回的顺序出现在列表中。
        Specified by:
        addAll in interface List<E>
        重写：
        addAll在类 AbstractSequentialList<E>
        参数
        index - 从指定集合插入第一个元素的索引
        c - 包含要添加到此列表的元素的集合
        结果
        true如果此列表因呼叫而更改
        异常
        IndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index > size() ）
        NullPointerException - 如果指定的集合为null

      • clear

        public void clear()
        从此列表中删除所有元素。 此调用返回后，列表将为空。
        Specified by:
        clear在界面 Collection<E>
        Specified by:
        clear在界面 List<E>
        重写：
        clear类 AbstractList<E>

      • get

        public E get​(int index)
        返回此列表中指定位置的元素。
        Specified by:
        get in interface List<E>
        重写：
        get类 AbstractSequentialList<E>
        参数
        index - 要返回的元素的索引
        结果
        此列表中指定位置的元素
        异常
        IndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index >= size() ）

      • set

        public E set​(int index,             E element)
        用指定的元素替换此列表中指定位置的元素。
        Specified by:
        set in interface List<E>
        重写：
        set在类 AbstractSequentialList<E>
        参数
        index - 要替换的元素的索引
        element - 要存储在指定位置的元素
        结果
        先前在指定位置的元素
        异常
        IndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index >= size() ）

      • add

        public void add​(int index,                E element)
        将指定元素插入此列表中的指定位置。 将当前位置的元素（如果有）和任何后续元素向右移动（将其添加到索引中）。
        Specified by:
        add在界面 List<E>
        重写：
        add类 AbstractSequentialList<E>
        参数
        index - 要插入指定元素的索引
        element - 要插入的元素
        异常
        IndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index > size() ）

      • remove

        public E remove​(int index)
        删除此列表中指定位置的元素。 将任何后续元素向左移位（从索引中减去一个元素）。 返回从列表中删除的元素。
        Specified by:
        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。
        Specified by:
        indexOf在界面 List<E>
        重写：
        indexOf在类 AbstractList<E>
        参数
        o - 要搜索的元素
        结果
        此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1

      • lastIndexOf

        public int lastIndexOf​(Object o)
        返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。 更正式的是，返回最高指数i如Objects.equals(o, get(i)) ，如果没有这样的指数则返回-1。
        Specified by:
        lastIndexOf在界面 List<E>
        重写：
        lastIndexOf在类 AbstractList<E>
        参数
        o - 要搜索的元素
        结果
        此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1

      • peek

        public E peek()
        检索但不删除此列表的头部（第一个元素）。
        Specified by:
        peek在界面 Deque<E>
        Specified by:
        peek在界面 Queue<E>
        结果
        此列表的头部，如果此列表为空， null
        从以下版本开始：
        1.5

      • element

        public E element()
        检索但不删除此列表的头部（第一个元素）。
        Specified by:
        element在界面 Deque<E>
        Specified by:
        element在界面 Queue<E>
        结果
        这份清单的负责人
        异常
        NoSuchElementException - 如果此列表为空
        从以下版本开始：
        1.5

      • poll

        public E poll()
        检索并删除此列表的头部（第一个元素）。
        Specified by:
        poll在界面 Deque<E>
        Specified by:
        poll in interface Queue<E>
        结果
        此列表的头部，如果此列表为空， null
        从以下版本开始：
        1.5

      • remove

        public E remove()
        检索并删除此列表的头部（第一个元素）。
        Specified by:
        remove在界面 Deque<E>
        Specified by:
        remove在界面 Queue<E>
        结果
        这份清单的负责人
        异常
        NoSuchElementException - 如果此列表为空
        从以下版本开始：
        1.5

      • offer

        public boolean offer​(E e)
        将指定的元素添加为此列表的尾部（最后一个元素）。
        Specified by:
        offer在界面 Deque<E>
        Specified by:
        offer在界面 Queue<E>
        参数
        e - 要添加的元素
        结果
        true （由 Queue.offer(E)指定）
        从以下版本开始：
        1.5

      • offerFirst

        public boolean offerFirst​(E e)
        在此列表的前面插入指定的元素。
        Specified by:
        offerFirst在接口 Deque<E>
        参数
        e - 要插入的元素
        结果
        true （由 Deque.offerFirst(E)指定）
        从以下版本开始：
        1.6

      • offerLast

        public boolean offerLast​(E e)
        在此列表的末尾插入指定的元素。
        Specified by:
        offerLast在界面 Deque<E>
        参数
        e - 要插入的元素
        结果
        true （由 Deque.offerLast(E)指定）
        从以下版本开始：
        1.6

      • peekFirst

        public E peekFirst()
        检索但不删除此列表的第一个元素，如果此列表为空，则返回 null 。
        Specified by:
        peekFirst在界面 Deque<E>
        结果
        此列表的第一个元素，如果此列表为空， null
        从以下版本开始：
        1.6

      • peekLast

        public E peekLast()
        检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null 。
        Specified by:
        peekLast在界面 Deque<E>
        结果
        此列表的最后一个元素，如果此列表为空， null
        从以下版本开始：
        1.6

      • pollFirst

        public E pollFirst()
        检索并删除此列表的第一个元素，如果此列表为空，则返回 null 。
        Specified by:
        pollFirst在界面 Deque<E>
        结果
        此列表的第一个元素，如果此列表为空， null
        从以下版本开始：
        1.6

      • pollLast

        public E pollLast()
        检索并删除此列表的最后一个元素，如果此列表为空，则返回 null 。
        Specified by:
        pollLast在界面 Deque<E>
        结果
        此列表的最后一个元素，如果此列表为空， null
        从以下版本开始：
        1.6

      • push

        public void push​(E e)
        将元素推送到此列表所表示的堆栈上。 换句话说，将元素插入此列表的前面。

        此方法相当于addFirst(E) 。

        Specified by:
        push在界面 Deque<E>
        参数
        e - 要推送的元素
        从以下版本开始：
        1.6

      • pop

        public E pop()
        弹出此列表所代表的堆栈中的元素。 换句话说，删除并返回此列表的第一个元素。

        此方法相当于removeFirst() 。

        Specified by:
        pop在接口 Deque<E>
        结果
        此列表前面的元素（此列表所代表的堆栈顶部）
        异常
        NoSuchElementException - 如果此列表为空
        从以下版本开始：
        1.6

      • removeFirstOccurrence

        public boolean removeFirstOccurrence​(Object o)
        删除此列表中第一次出现的指定元素（从头到尾遍历列表时）。 如果列表不包含该元素，则不会更改。
        Specified by:
        removeFirstOccurrence在界面 Deque<E>
        参数
        o - 要从此列表中删除的元素（如果存在）
        结果
        true如果列表包含指定的元素
        从以下版本开始：
        1.6

      • removeLastOccurrence

        public boolean removeLastOccurrence​(Object o)
        删除此列表中最后一次出现的指定元素（从头到尾遍历列表时）。 如果列表不包含该元素，则不会更改。
        Specified by:
        removeLastOccurrence在界面 Deque<E>
        参数
        o - 要从此列表中删除的元素（如果存在）
        结果
        true如果列表包含指定的元素
        从以下版本开始：
        1.6

      • listIterator

        public ListIterator<E> listIterator​(int index)
        从列表中的指定位置开始，返回此列表中元素的列表迭代器（按正确顺序）。 List.listIterator(int)的总合同为List.listIterator(int) 。

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

        Specified by:
        listIterator在界面 List<E>
        Specified by:
        listIterator在类 AbstractSequentialList<E>
        参数
        index - 从list-iterator返回的第一个元素的索引（通过调用 next ）
        结果
        此列表中元素的ListIterator（按正确顺序），从列表中的指定位置开始
        异常
        IndexOutOfBoundsException - 如果指数超出范围（ index < 0 || index > size() ）
        另请参见：
        List.listIterator(int)

      • descendingIterator

        public Iterator<E> descendingIterator()
        从界面复制的说明： Deque
        以相反的顺序返回此双端队列中元素的迭代器。 元素将按从最后（尾部）到第一个（头部）的顺序返回。
        Specified by:
        descendingIterator在界面 Deque<E>
        结果
        以相反顺序遍历此双端队列中的元素的迭代器
        从以下版本开始：
        1.6

      • clone

        public Object clone()
        返回此LinkedList的浅表副本。 （元素本身未被克隆。）
        重写：
        clone类 Object
        结果
        这个 LinkedList实例的浅表副本
        另请参见：
        Cloneable

      • toArray

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

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

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

        Specified by:
        toArray在界面 Collection<E>
        Specified by:
        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() 。
        Specified by:
        toArray在界面 Collection<E>
        Specified by:
        toArray在界面 List<E>
        重写：
        toArray在类 AbstractCollection<E>
        参数类型
        T - 包含集合的数组的组件类型
        参数
        a - 列表元素要存储的数组，如果它足够大; 否则，为此目的分配相同运行时类型的新数组。
        结果
        包含列表元素的数组
        异常
        ArrayStoreException - 如果指定数组的运行时类型不是此列表中每个元素的运行时类型的超类型
        NullPointerException - 如果指定的数组为null