LinkedList源码解析和设计思路

一、 继承体系

LinkedList类位于java.util包中，它实现了List接口和Deque接口，LinkedList可以被当做链表、双端队列使用，并且继承自AbstractSequentialList类。在继承关系中，它的父类是AbstractSequentialList，而AbstractSequentialList又继承自AbstractList，AbstractList继承自AbstractCollection，AbstractCollection实现了Collection接口。

二、设计目的

LinkedList的设计目的是为了提供一个基于链表的动态数组实现，它可以高效地进行插入、删除操作，并且能够按照索引快速访问元素。与ArrayList不同，LinkedList不需要预先分配固定大小的空间，因此适用于频繁插入、删除操作的场景。

三、框架总结结构

LinkedList采用双向链表的数据结构来存储元素，每个节点包含指向前一个节点和后一个节点的引用。它提供了add、remove、get等操作方法，以及支持队列和栈的操作方法。LinkedList还实现了ListIterator接口，可以进行双向迭代操作。

四、工作原理

在LinkedList中，每次添加或删除元素时，它会重新调整节点之间的引用关系，保证链表的正确性。在添加元素时，它会创建一个新的节点并将其插入到链表中，并更新前后节点的引用；在删除元素时，它会修改前后节点的引用，使得被删除节点脱离链表。由于LinkedList采用双向链表的结构，因此在插入和删除元素时，时间复杂度为O(1)。

五、如何创建LinkedList？

{
    transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first; //指向第一个节点的指针，首节点的元素类型为 E

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last; //指向第一个节点的指针，首节点的元素类型为 E。

    /**
     * Constructs an empty list.
     */
    public LinkedList() {
    }

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param  c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

• LinkedList类的构造函数。第一个构造函数是无参构造函数，用于构造一个空的LinkedList实例。
• 第二个构造函数接受一个集合参数c，并将该集合中的元素按照迭代器返回的顺序添加到LinkedList中。首先调用了无参构造函数this()来初始化一个空的LinkedList，然后调用addAll方法将集合c中的所有元素添加到LinkedList中。
• 这样设计的意义在于提供了创建LinkedList的灵活性，可以直接传入一个集合来初始化LinkedList。

六、add（E e）添加源码

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

linkLast(e)方法将元素e链接到链表的末尾，然后返回true表示添加元素成功。 linkLast(e) 方法会在链表末尾添加一个新节点，并更新链表的相关指针。

void linkLast(E e) {
    final Node<E> l = last;  // 将当前链表的最后一个节点赋值给变量l，用final修饰表示l是一个不可变的引用

    final Node<E> newNode = new Node<>(l, e, null);  // 创建一个新节点newNode，其中：
                                                     // - 前驱节点指向l，即当前链表的最后一个节点
                                                     // - 元素为e，即要添加到链表中的元素
                                                     // - 后继节点暂时为null，因为这是新节点添加到最后一个位置

    last = newNode;  // 更新last指针，使其指向新节点newNode，表示新节点成为了链表中的最后一个节点

    if (l == null)
        first = newNode;  // 如果原链表为空（即l为null），将first指针指向新节点newNode，表示此时链表只包含一个节点，即newNode
    else
        l.next = newNode;  // 如果原链表不为空，则将当前链表最后一个节点的next指针指向新节点newNode，让新节点成为原链表中最后一个节点的后继节点

    size++;  // 增加链表的大小，表示成功在链表尾部添加了一个新节点

    modCount++;  // 修改计数器，用于记录对LinkedList结构进行修改的次数，以便在迭代过程中检测并发修改操作
}

1. final Node<E> l = last;

   • 将当前链表的最后一个节点存储在变量l中，使用final关键字表示l是一个不可变的引用。

2. final Node<E> newNode = new Node<>(l, e, null);

   • 创建一个新的节点newNode，包括：
     • 前驱节点指向l，即指向当前链表的最后一个节点
     • 元素为e，即要添加到链表中的元素
     • 后继节点暂时为null，因为这是要将新节点添加到链表末尾

3. last = newNode;

   • 更新last指针，使其指向新创建的节点newNode，表示新节点成为了链表中的最后一个节点。

4. if (l == null)

   • 检查原链表是否为空（即l为null）。

5. first = newNode;

   • 如果原链表为空，则将first指针指向新节点newNode，表示此时链表只包含一个节点，即newNode。

6. else

   • 如果原链表不为空，则执行以下操作：

7. l.next = newNode;

   • 让当前链表最后一个节点的next指针指向新节点newNode，让新节点成为原链表中最后一个节点的后继节点。

8. size++;

   • 增加链表的大小，表示成功在链表尾部添加了一个新节点。

9. modCount++;

   • 修改计数器，用于记录对LinkedList结构进行修改的次数，以便在迭代过程中检测并发修改操作。

---

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

1. E item;

   • 定义了一个泛型类型E的变量item，用于存储节点中的元素值。

2. Node<E> next;

   • 定义了一个泛型类型为Node的变量next，表示指向链表中下一个节点的引用。

3. Node<E> prev;

   • 定义了一个泛型类型为Node的变量prev，表示指向链表中上一个节点的引用。

4. Node(Node<E> prev, E element, Node<E> next) {

   • 定义了Node类的构造函数，包括如下参数：
     • prev: 前驱节点的引用
     • element: 节点中的元素值
     • next: 后继节点的引用

5. this.item = element;

   • 将传入的element赋值给节点的item属性，表示该节点存储了对应的元素值。

6. this.next = next;

   • 将传入的next引用赋值给节点的next属性，表示该节点指向链表中的下一个节点。

7. this.prev = prev;

   • 将传入的prev引用赋值给节点的prev属性，表示该节点指向链表中的上一个节点。

---

从头部追加（addFirst）

     LinkedList arrayList = new LinkedList ();
     arrayList.addFirst("头部");

    private 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++;
    } 

1. private void linkFirst(E e) {

   • 定义了一个私有方法linkFirst，用于在链表的开头添加一个新节点，参数e表示要添加的元素。

2. final Node<E> f = first;

   • 通过final关键字将当前链表的第一个节点（头节点）赋值给变量f。

3. final Node<E> newNode = new Node<>(null, e, f);

   • 创建一个新的节点newNode，其中：
     • 前驱节点为null，因为新节点将成为头节点
     • 元素为e，即要添加到链表中的元素
     • 后继节点为f，即原来的头节点

4. first = newNode;

   • 更新first指针，使其指向新创建的头节点newNode。

5. if (f == null)

   • 检查原链表是否为空（即f为null）。

6. last = newNode;

   • 如果原链表为空，则将last指针也指向新的头节点newNode。

7. else

   • 如果原链表不为空，则执行以下操作：

8. f.prev = newNode;

   • 将原来的头节点的prev指针指向新的头节点newNode，建立双向连接。

9. size++;

   • 增加链表的大小，表示成功在链表开头添加了一个新的节点。

10. modCount++;
    修改计数器，用于记录对LinkedList结构进行修改的次数，以便在迭代过程中检测并发修改操作。

七、remove(Object o)删除源码

public boolean remove(Object o) { // 定义一个方法，用于从数据结构中移除特定对象
    if (o == null) { // 如果传入的对象为空
        for (Node<E> x = first; x != null; x = x.next) { // 遍历链表直到最后一个节点
            if (x.item == null) { // 如果当前节点存储的对象为空
                unlink(x); // 调用unlink方法将该节点从链表中移除
                return true; // 返回true，表示移除成功
            }
        }
    } else { // 如果传入的对象不为空
        for (Node<E> x = first; x != null; x = x.next) { // 遍历链表直到最后一个节点
            if (o.equals(x.item)) { // 如果传入的对象等于当前节点存储的对象
                unlink(x); // 调用unlink方法将该节点从链表中移除
                return true; // 返回true，表示移除成功
            }
        }
    }
    return false; // 如果遍历完链表都没有找到匹配的对象，则返回false，表示移除失败
}

总结：如果传入的对象为空，则遍历链表直到找到存储的对象也为空的节点，然后将其从链表中移除。如果传入的对象不为空，则遍历链表直到找到与传入对象相等的节点，然后将其从链表中移除。如果未找到匹配的对象，则返回false表示移除失败。

---

/**
 * Unlinks non-null node x.
 */
E unlink(Node<E> x) { // 定义了一个方法，用于移除非空节点x
    final E element = x.item; // 获取节点x存储的元素
    final Node<E> next = x.next; // 获取节点x的下一个节点
    final Node<E> prev = x.prev; // 获取节点x的前一个节点

    if (prev == null) { // 如果节点x的前一个节点为空
        first = next; // 将链表的头指针指向节点x的下一个节点
    } else {
        prev.next = next; // 将节点x的前一个节点的next指针指向节点x的下一个节点
        x.prev = null; // 将节点x的prev指针置为空
    }

    if (next == null) { // 如果节点x的下一个节点为空
        last = prev; // 将链表的尾指针指向节点x的前一个节点
    } else {
        next.prev = prev; // 将节点x的下一个节点的prev指针指向节点x的前一个节点
        x.next = null; // 将节点x的next指针置为空
    }

    x.item = null; // 将节点x的元素置为空
    size--; // 链表大小减一
    modCount++; // 修改次数加一
    return element; // 返回被移除节点x的元素
}

八、 get（）查找

/**
 * Returns the (non-null) Node at the specified element index.
 */
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; // 返回找到的节点
    }
}

根据索引值快速定位链表中的节点，通过前半部分和后半部分遍历的方式提高了效率。

LinkedList 总结用法和使用场景：

• 用法：LinkedList 是一个双向链表实现的 List，支持在任意位置进行元素的插入和删除操作。可以作为队列（Queue）或双端队列（Deque）使用。
• 使用场景：适合对列表进行频繁的插入和删除操作，因为插入和删除节点的开销较小。特别适合需要在中间插入元素的场景。由于每个节点在内存中不连续存储，可能会增加内存占用。

LinkedList 性能总结：

• 查询性能：LinkedList 在查询时需要遍历链表，时间复杂度为 O(n)，效率较低。
• 插入/删除性能：在列表的开头或中间插入/删除元素时，LinkedList 的性能优于 ArrayList，因为只需要调整指针即可。
• 迭代性能：LinkedList 在迭代访问元素时，效率较高，不会涉及数组复制等操作。

与 ArrayList 方法对比：

• ArrayList：底层基于数组实现，随机访问快，但插入和删除元素开销较大，需要移动后续元素。适合读取操作多于修改操作的场景。
• 对比：
  • LinkedList 适合频繁插入和删除元素的场景，而 ArrayList 更适合于随机访问元素。
  • LinkedList 的插入和删除操作性能更好，但查询性能较差；ArrayList 的查询性能更好，但在插入和删除方面效率相对较低。