## 深入分析 Java 中的 `LinkedList` 源码

`LinkedList` 是 Java 集合框架中的一个重要类，它基于双向链表实现，提供了高效的插入和删除操作。与 `ArrayList` 不同，`LinkedList` 的结构使其在特定操作上有更优的性能表现。本文将详细分析 `LinkedList` 的源码，包括其数据结构、构造方法、核心操作等。

### 1. `LinkedList` 的基本数据结构

`LinkedList` 是基于双向链表实现的，这意味着每个节点都包含对前一个节点和后一个节点的引用。`LinkedList` 主要由以下几个关键字段组成：

```java
public class LinkedList<E> extends AbstractSequentialList<E>
        implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
    transient int size = 0;
    transient Node<E> first;
    transient Node<E> last;

    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;
        }
    }
}
```

- `size`：链表中的元素数量。
- `first`：指向链表的第一个节点。
- `last`：指向链表的最后一个节点。
- `Node`：链表节点的内部类，每个节点包含元素数据和前后节点的引用。

### 2. 构造方法

`LinkedList` 提供了多个构造方法：

#### 2.1 默认构造方法

```java
public LinkedList() {
}
```

默认构造方法初始化一个空的链表。

#### 2.2 从另一个集合创建 `LinkedList`

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

此构造方法从另一个集合创建 `LinkedList`，并将集合中的所有元素添加到链表中。

### 3. 核心操作方法

#### 3.1 添加元素

`LinkedList` 提供了多种添加元素的方法：

##### 3.1.1 在链表末尾添加元素

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

void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}
```

- `add(E e)`：在链表末尾添加元素。
- `linkLast(E e)`：将新节点链接到链表的末尾。如果链表为空，则新节点既是 `first` 也是 `last`。

##### 3.1.2 在指定位置插入元素

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

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

void linkBefore(E e, Node<E> succ) {
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}
```

- `add(int index, E element)`：在指定位置插入元素。
- `linkBefore(E e, Node<E> succ)`：在指定节点之前插入新节点。
- `node(int index)`：返回指定位置的节点。

##### 3.1.3 添加元素到链表的头部

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

void linkFirst(E e) {
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}
```

- `addFirst(E e)`：在链表头部添加元素。
- `linkFirst(E e)`：将新节点链接到链表的头部。如果链表为空，则新节点既是 `first` 也是 `last`。

#### 3.2 删除元素

`LinkedList` 提供了多种删除元素的方法：

##### 3.2.1 删除指定位置的元素

```java
public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

E unlink(Node<E> x) {
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

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

    x.item = null;
    size--;
    modCount++;
    return element;
}
```

- `remove(int index)`：删除指定位置的元素。
- `unlink(Node<E> x)`：断开指定节点的链接，并返回节点中的元素。

##### 3.2.2 删除链表的头部元素

```java
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

private E unlinkFirst(Node<E> f) {
    final E element = f.item;
    final Node<E> next = f.next;
    f.item = null;
    f.next = null; // help GC
    first = next;
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}
```

- `removeFirst()`：删除链表的头部元素。
- `unlinkFirst(Node<E> f)`：断开头部节点的链接，并返回节点中的元素。

##### 3.2.3 删除链表的尾部元素

```java
public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}

private E unlinkLast(Node<E> l) {
    final E element = l.item;
    final Node<E> prev = l.prev;
    l.item = null;
    l.prev = null; // help GC
    last = prev;
    if (prev == null)
        first = null;
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}
```

- `removeLast()`：删除链表的尾部元素。
- `unlinkLast(Node<E> l)`：断开尾部节点的链接，并返回节点中的元素。

#### 3.3 获取元素和修改元素

`LinkedList` 提供了获取和修改元素的方法：

##### 3.3.1 获取元素

```java
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

Node<E> node(int index) {
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}
```

- `get(int index)`：根据索引获取元素。
- `node(int index)`：返回指定位置的节点，通过判断索引位置决定从前往后还是从后往前遍历，提高效率。

##### 3.3.2 修改元素

```java
public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}
```

- `set(int index, E element)`：根据索引修改元素，并返回旧元素。

### 4. 双向链表的结构特点

#### 4.1 链表节点的定义

在 `LinkedList` 中，每个节点包含一个元素和对前后节点的引用：

```java
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;
    }
}
```

- `item`：存储节点的元素。
- `next`：指向下一个节点。
- `prev`：指向前一个节点。

#### 4.2 链表的首尾节点

`LinkedList` 通过 `first` 和 `last` 字段分别指向链表的首节点和尾节点，这样可以高效地进行头部和尾部的插入和删除操作。