Java集合-LinkedList源码分析

目录

• 1.数据结构-链表
• 2.ArrayList结构特性
• 3.构造方法
• 4.成员变量
• 5.常用的成员方法
• 6.Node节点
• 7.序列化原理
• 8.迭代器
• 9.总结

1.数据结构-链表

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。

使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

链表的类型：

• 单向链表：单向链表包含两个域，一个信息域和一个指针域。这个链接指向列表中的下一个节点，而最后一个节点则指向一个空值。

• 双向链表：双向链表每个节点有两个连接：一个指向前一个节点，（当此“连接”为第一个“连接”时，指向空值或者空列表）；而另一个指向下一个节点，（当此“连接”为最后一个“连接”时，指向空值或者空列表）

• 循环链表：在一个循环链表中, 首节点和末节点被连接在一起。

2.ArrayList结构特性

LinkedList 与 ArrayList 一样实现 List 接口，只是 ArrayList 是 List 接口的大小可变数组的实现，LinkedList 是 List 接口链表的实现。有以下特性：

• 允许包含重复的元素
• 允许包含null元素
• 保存了元素添加的顺序
• 不是线程安全的

3.构造方法

// 1.构造一个空列表
LinkedList()

// 2.构造一个包含指定集合元素的列表
LinkedList(Collection<? extends E> c)

4.成员变量

// 1.链表中的元素数
transient int size

// 2.指向第一个元素的指针
transient Node<E> first

// 3.指向最后一个元素的指针
transient Node<E> last

5.常用的成员方法

// 1.添加一个元素到列表的尾部
boolean add(E e)

// 2.添加一个元素到列表的指定位置
void add(int index, E element)

// 3.将指定集合中的所有元素追加到此列表的末尾。
boolean addAll(Collection<? extends E> c)

// 4.添加一个元素到列表的头部
void addFirst(E e)

// 5.添加一个元素到列表的尾部
addLast(E e)

// 6.检查列表中包含指定的元素
boolean contains(Object o)

// 7.返回列表的第一个元素
E element()

// 8.返回列表指定位置的元素
E get(int index)

// 9.返回指定元素在列表中首次出现的索引
int indexOf(Object o)

// 10.返回指定元素在列表中最后一次出现的索引
int lastIndexOf(Object o)

// 11.添加一个元素到列表的尾部
boolean offer(E e)

// 12.返回列表的第一个元素
E peek()

// 13.删除并返回此列表的第一个元素
E poll()

// 14.删除并返回此列表的第一个元素
E pop()

// 15.添加一个元素到列表的头部
void push(E e)

// 16.移除列表的第一个元素
E remove()

// 17.设置指定位置的元素
E set(int index, E element)

// 18.返回列表中的元素数
int size()

// 19.返回一个数组，包含列表中所有元素
Object[] toArray()

6.Node节点

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

7.序列化原理

1.LinkedList 实现了Serializable接口，支持对象序列化

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
      ......
}

2.序列化时调用 writeObject 方法，将 size 和 node 节点列表写入 ObjectOutputStream。

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

    // 序列化 size
    s.writeInt(size);

    // 从第一个元素开始，将链表中所有的元素序列化
    for (Node<E> x = first; x != null; x = x.next)
        s.writeObject(x.item);
}

3.反序列化时调用 readObject 方法，恢复 size 和 node 节点列表。

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

    // 恢复size
    int size = s.readInt();

    // 恢复链表
    for (int i = 0; i < size; i++)
        linkLast((E)s.readObject());
}

4.成员变量 size、first 和 last 使用 transient 关键字修饰，不会序列化到目的地中，从而节省时间和空间。

8.迭代器

1.由LinedList内部类ListItr实现ListIterator 接口，间接实现Iterator 接口。

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;

    ......
}

2.ListItr实现迭代器的成员方法

// 检查指针索引指向链表的边界
public boolean hasNext() {
      return nextIndex < size;
}

// 返回next 指向的节点，同时next偏移下一个节点
public E next() {
      ......
}

// 移除最近返回的节点（lastReturned引用）
public void remove() {
      ......
}

9.总结

以上就是对LinkedList的理解，如果有不正确的地方，欢迎指正，最后，补一张脑图：