Java-API简析_java.util.LinkedList＜E＞类（基于 Latest JDK）（浅析源码）

【版权声明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）
https://blog.csdn.net/m0_69908381/article/details/130727525
出自【进步*于辰的博客】

注：依赖类：Class<T>。

1、概述

继承关系：

• 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>、List<E>、Queue<E>

---

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

List 接口的$链接列表$实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get()、remove() 和 insert() 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列 (deque)。

此类实现 Queue 接口，为 add()、poll() 等提供先进先出队列操作。其他堆栈和双端队列操作可以根据标准列表操作方便地进行再次强制转换。虽然它们可能比等效列表操作运行稍快，但是将其包括在这里主要是出于方便考虑。

所有操作都是按照双重链接列表的需要执行的。在列表中$编索引$的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。

$注意，此实现不是同步的$。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须保持外部同步（“结构修改”指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改）。这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList() 方法来“包装”该列表。最好在创建时完成这一操作，以防止对列表进行意外的不同步访问，如下所示：

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

此类的 iterator() 和 listIterator() 方法返回的迭代器是 快速失败 的：在迭代器创建之后，如果从结构上对列表进行修改，除非通过迭代器自身的 remove() 或 add()，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒将来不确定的时间任意发生不确定行为的风险。

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

此类是 Java Collections Framework 的成员。

从以下版本开始：
1.2
另请参见：
List<E>、ArrayList<E>、Vector<E>、Collections.synchronizedList(List)、序列化表格

2、构造方法摘要

2.1 null

构造一个空列表。

底层无代码。

2.2 Collection<? extends E> c

构造一个包含指定集合中的元素的列表，这些元素按其集合的迭代器返回的顺序排列。

public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

关于addAll()，见第3.3项。

3、方法摘要

3.1 boolean add(E o)

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

public boolean add(E e) {
    linkLast(e);
    return true;
}

关于linkLast()，见第7.1项。

3.2 void add(int index, E element)

在此列表中指定的位置插入指定的元素。

public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);// 添加到末尾
    else
        linkBefore(element, node(index));// 插入
}

关于checkPositionIndex()，见第7.4项；关于linkLast()，见第7.1项；关于node()，见第7.2项；关于linkBefore()，见第7.3项。

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

追加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。

public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}

调用下1项。

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

将指定集合中的所有元素从指定位置开始插入此列表。

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

    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;

    Node<E> pred, succ;
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }

    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
        Node<E> newNode = new Node<>(pred, e, null);
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }

    if (succ == null) {
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }

    size += numNew;
    modCount++;
    return true;
}

关于toArray()，见第27项。

后续补充解析。

3.5 void addFirst(E o)

将给定元素插入此列表的开头。

public void addFirst(E e) {
    linkFirst(e);
}

调用第7.6项。

3.6 void addLast(E o)

将给定元素追加到此列表的结尾。

public void addLast(E e) {
    linkLast(e);
}

调用第7.1项。

3.7 void clear()

从此列表中移除所有元素。

3.8 Object clone()

返回此 LinkedList 的浅表复制。

3.9 boolean contains(Object o)

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

3.10 E element()

找到但不移除此列表的头（第一个元素）。

3.11 E get(int index)

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

3.12 E getFirst()

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

3.13 E getLast()

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

3.14 int indexOf(Object o)

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

3.15 int lastIndexOf(Object o)

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

3.16 ListIterator<E> listIterator(int index)

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

3.17 boolean offer(E o)

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

3.18 E peek()

找到但不移除此列表的头（第一个元素）。

3.19 E poll()

找到并移除此列表的头（第一个元素）。

3.20 E remove()

找到并移除此列表的头（第一个元素）。

3.21 E remove(int index)

移除此列表中指定位置处的元素。

3.22 boolean remove(Object o)

移除此列表中首次出现的指定元素。

3.23 E removeFirst()

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

3.24 E removeLast()

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

3.25 E set(int index, E element)

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

3.26 int size()

返回此列表的元素数。

3.27 Object[] toArray()

以正确顺序返回包含此列表中所有元素的数组。

public Object[] toArray() {
    Object[] result = new Object[size];
    int i = 0;
    for (Node<E> x = first; x != null; x = x.next)
        result[i++] = x.item;
    return result;
}

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

以正确顺序返回包含此列表中所有元素的数组；返回数组的运行时类型即为指定数组的类型。

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        a = (T[])java.lang.reflect.Array.newInstance(
                            a.getClass().getComponentType(), size);
    int i = 0;
    Object[] result = a;
    for (Node<E> x = first; x != null; x = x.next)
        result[i++] = x.item;

    if (a.length > size)
        a[size] = null;

    return a;
}

关于getComponentType()，见 Class 类的第2.11项。即返回数组的组件类型componentType。如：若a的类型是是Integer[]，则componentType是Integer.class。
关于newInstance()，由于暂未解析 Array 类，故无法出示此方法源码。不过，经底层解析可判断，其返回值是new componentType[newLength]。

其他源码解析可参考列表类的第3.14项。

4、嵌套类 Node<E>

链表节点。

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

5、属性摘要（不开放）

5.1 transient Node<E> first

第一个节点。

transient Node<E> first;

判定有效条件：（固定）

first == null && last == null;// 此链表为空
或
first.prev == null && first.item != null;// 当 first 本身有值，而无上1个节点。

5.2 transient Node<E> last

最后一个节点。

transient Node<E> last;

判定有效条件：（固定）

first == null && last == null;// 此链表为空
或
last.next == null && last.item != null;// 当 last 本身有值，而无下1个节点

7、方法摘要（不开放）

7.1 void linkLast(E e)

使用指定值构造节点添加到链表表尾位置。

关于modCount，见列表类的第6.1项。

7.2 Node<E> node(int index)

根据指定索引获取节点。

7.3 void linkBefore(E e, Node<E> succ)

使用指定值构造节点插入到指定节点位置。

关于modCount，见列表类的第6.1项。

7.4 private void checkPositionIndex(int index)

判断指定索引是否在链表范围内。

private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}

7.6 private void linkFirst(E e)

使用指定值构造节点插入到链表表头位置。

关于modCount，见列表类的第6.1项。

最后

如果大家需要Java-API文档，我上传了《Java-API文档-包含5/8/11三个版本》。

---

本文暂缓更新。