java-linkedlist 源码分析 2

### 5. 迭代器支持

`LinkedList` 实

现了 `Iterable` 接口，提供了支持迭代的功能：

```java
public Iterator<E> iterator() {
    return new ListItr(0);
}

public ListIterator<E> listIterator(int index) {
    checkPositionIndex(index);
    return new ListItr(index);
}

private class ListItr implements ListIterator<E> {
    private Node<E> lastReturned;
    private Node<E> next;
    private int nextIndex;
    private int expectedModCount = modCount;

    ListItr(int index) {
        next = (index == size) ? null : node(index);
        nextIndex = index;
    }

    public boolean hasNext() {
        return nextIndex < size;
    }

    public E next() {
        checkForComodification();
        if (!hasNext())
            throw new NoSuchElementException();

        lastReturned = next;
        next = next.next;
        nextIndex++;
        return lastReturned.item;
    }

    public boolean hasPrevious() {
        return nextIndex > 0;
    }

    public E previous() {
        checkForComodification();
        if (!hasPrevious())
            throw new NoSuchElementException();

        lastReturned = next = (next == null) ? last : next.prev;
        nextIndex--;
        return lastReturned.item;
    }

    public void remove() {
        checkForComodification();
        if (lastReturned == null)
            throw new IllegalStateException();

        Node<E> lastNext = lastReturned.next;
        unlink(lastReturned);
        if (next == lastReturned)
            next = lastNext;
        else
            nextIndex--;
        lastReturned = null;
        expectedModCount++;
    }

    public void set(E e) {
        if (lastReturned == null)
            throw new IllegalStateException();
        checkForComodification();
        lastReturned.item = e;
    }

    public void add(E e) {
        checkForComodification();
        lastReturned = null;
        if (next == null)
            linkLast(e);
        else
            linkBefore(e, next);
        nextIndex++;
        expectedModCount++;
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}
```

### 6. 序列化与克隆

#### 6.1 序列化

`LinkedList` 实现了 `Serializable` 接口，允许其对象被序列化。序列化和反序列化通过 `writeObject` 和 `readObject` 方法自定义处理。

```java
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
    // Write out any hidden serialization magic
    s.defaultWriteObject();

    // Write out size
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (Node<E> x = first; x != null; x = x.next)
        s.writeObject(x.item);
}

private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
    // Read in any hidden serialization magic
    s.defaultReadObject();

    // Read in size
    int size = s.readInt();

    // Read in all elements in the proper order.
    for (int i = 0; i < size; i++)
        linkLast((E) s.readObject());
}
```

- `writeObject`：序列化 `LinkedList` 对象，包括元素数量和所有元素。
- `readObject`：反序列化 `LinkedList` 对象，根据序列化的数据恢复链表结构。

#### 6.2 克隆

`LinkedList` 实现了 `Cloneable` 接口，提供了 `clone` 方法用于深度克隆。

```java
public Object clone() {
    LinkedList<E> clone = super.clone();

    // Put clone into "virgin" state
    clone.first = clone.last = null;
    clone.size = 0;
    clone.modCount = 0;

    // Initialize clone with our elements
    for (Node<E> x = first; x != null; x = x.next)
        clone.add(x.item);

    return clone;
}
```

- `clone` 方法通过 `super.clone` 创建一个新的 `LinkedList` 实例，并逐个复制元素到新实例中。

### 7. 性能分析

#### 7.1 时间复杂度

- **添加元素**：在头部或尾部添加元素的时间复杂度为 O(1)。
- **删除元素**：在头部或尾部删除元素的时间复杂度为 O(1)。
- **随机访问**：随机访问元素的时间复杂度为 O(n)。
- **插入和删除操作**：在链表中间插入和删除元素的时间复杂度为 O(n)，因为需要遍历链表找到指定位置。

#### 7.2 空间复杂度

`LinkedList` 使用链表节点来存储元素，每个节点包含元素数据和前后节点的引用。因此，`LinkedList` 的空间复杂度主要取决于元素数量和节点的开销。

### 8. `LinkedList` 的缺点和使用场景

#### 8.1 缺点

- **随机访问效率低**：由于链表不支持通过索引快速访问元素，随机访问元素的时间复杂度为 O(n)。
- **额外内存开销**：每个节点需要存储前后节点的引用，因此链表的内存开销较高。

#### 8.2 使用场景

- **插入和删除操作频繁**：在需要频繁进行插入和删除操作的场景中，`LinkedList` 的性能优于 `ArrayList`。
- **元素数量动态变化**：当元素数量经常变化且需要在中间插入和删除时，`LinkedList` 是一个不错的选择。

### 9. `LinkedList` 的替代方案

在特定场景下，其他集合类可能比 `LinkedList` 更合适。例如：

- **`ArrayList`**：`ArrayList` 适用于需要频繁进行随机访问和遍历的场景，其插入和删除操作性能较低。
- **`Deque`**：双端队列（`Deque`）提供了类似 `LinkedList` 的功能，并且有多种实现，如 `ArrayDeque` 和 `LinkedList`。
- **`Stack`**：如果主要使用 `LinkedList` 的栈功能，可以考虑使用 `Stack` 类，但需要注意 `Stack` 是同步的，性能相对较低。

### 10. 总结

`LinkedList` 是 Java 集合框架中的一个重要类，提供了基于双向链表的集合实现。通过详细分析 `LinkedList` 的源码，可以更好地理解其内部机制和工作原理。`LinkedList` 适用于频繁进行插入和删除操作的场景，但在随机访问和遍历操作上性能较低。

通过深入了解 `LinkedList` 的数据结构、构造方法、核心操作、迭代器支持、序列化与克隆等，可以更有效地使用 `LinkedList` 并优化程序性能。同时，了解其局限性和替代方案，有助于在不同应用场景中选择最合适的集合类。