• LinkedList源码分析

    一、概述

    LinkedList是 Java 集合框架中一个重要的实现，其底层采用的双向链表结构。和 ArrayList 一样，LinkedList 也支持空值和重复值。由于 LinkedList 基于链表实现，存储元素过程中，无需像 ArrayList 那样进行扩容。

    但有得必有失，一方面，LinkedList 存储元素的节点需要额外的空间存储前驱和后继的引用。另一方面，LinkedList 在链表头部和尾部插入效率比较高，但在指定位置进行插入时，效率一般。原因是，在指定位置插入需要定位到该位置处的节点，此操作的时间复杂度为O(N)。

    最后，LinkedList 是非线程安全的集合类，并发环境下，多个线程同时操作 LinkedList，会引发不可预知的错误。

    二、继承体系

    LinkedList 的继承体系较为复杂，继承自 AbstractSequentialList，同时又实现了 List 和 Deque 接口 

    LinkedList 继承自 AbstractSequentialList，AbstractSequentialList 又是什么呢？从实现上，AbstractSequentialList 提供了一套基于顺序访问的接口。通过继承此类，子类仅需实现部分代码即可拥有完整的一套访问某种序列表（比如链表）的接口。深入源码，AbstractSequentialList 提供的方法基本上都是通过 ListIterator 实现的，比如： 

    1. public abstract class AbstractSequentialList extends AbstractList {
    2.  
    3.     public E get(int index) {
    4.         try {
    5.             return listIterator(index).next();
    6.         } catch (NoSuchElementException exc) {
    7.             throw new IndexOutOfBoundsException("Index: "+index);
    8.         }
    9.     }
    10.  
    11.     public void add(int index, E element) {
    12.         try {
    13.             listIterator(index).add(element);
    14.         } catch (NoSuchElementException exc) {
    15.             throw new IndexOutOfBoundsException("Index: "+index);
    16.         }
    17.     }
    18.  
    19.     //留给子类实现
    20.     public abstract ListIterator listIterator(int index);
    21. }

    所以只要继承类实现了 listIterator 方法，它不需要再额外实现什么即可使用。对于随机访问集合类一般建议继承 AbstractList 而不是 AbstractSequentialList。LinkedList 和其父类一样，也是基于顺序访问。所以 LinkedList 继承了 AbstractSequentialList，但 LinkedList 并没有直接使用父类的方法，而是重新实现了一套的方法。

    另外，LinkedList 还实现了 Deque (double ended queue)，Deque 又继承自 Queue 接口。这样 LinkedList 就具备了队列的功能。比如，我们可以这样使用：

    Queue queue = new LinkedList<>();

    除此之外，我们基于 LinkedList 还可以实现一些其他的数据结构，比如栈，以此来替换 Java 集合框架中的 Stack 类。

    三、源码分析

    1、成员属性

    1.     // 元素个数
    2.     transient int size = 0;
    3.  
    4.     // 链表头节点
    5.     transient Node first;
    6.     
    7.     // 链表尾节点
    8.     transient Node last;

    2、Node节点 

    1.     private static class Node {
    2.         //数据域，实际存放的元素，节点的值
    3.         E item;
    4.         //后继，储存下一个节点的引用
    5.         Node next;
    6.         //前驱，储存上一个节点的引用
    7.         Node prev;
    8.  
    9.         //构造函数
    10.         Node(Node prev, E element, Node next) {
    11.             this.item = element;
    12.             this.next = next;
    13.             this.prev = prev;
    14.         }
    15.     }

    3、构造器

    构造一个空列表，里面没有任何实现，只是进行了初始化操作。

    1.     public LinkedList() {
    2.     }

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

    1.     public LinkedList(Collection c) {
    2.         this();
    3.         addAll(c);
    4.     }

    4、增加元素

    1）增加头节点

    1.     public void addFirst(E e) {
    2.         //内部调用linkFirst方法
    3.         linkFirst(e);
    4.     }
    5.  
    6.     private void linkFirst(E e) {
    7.         //创建一个节点引用l，指向原头节点
    8.         final Node f = first;
    9.         //创建新节点，前驱为null，后继为当前头节点
    10.         final Node newNode = new Node<>(null, e, f);
    11.         //新的要插入的节点作为新的头节点
    12.         first = newNode;
    13.  
    14.         //判断原头节点是否为null，即原集合有没有节点数据
    15.         if (f == null)
    16.             //判断原头节点是否为null，即原集合有没有节点数据
    17.             last = newNode;
    18.         else
    19.             //如果原头节点不为null，即原集合有节点数据，那么将原来头节点的prev引用指向新的头节点
    20.             f.prev = newNode;
    21.  
    22.         //节点数自增1
    23.         size++;
    24.         //结构改变的次数自增1
    25.         modCount++;
    26.     }

    其他添加到尾部的方法，原理都是一样的：

    1.     public boolean offerFirst(E e) {
    2.         addFirst(e);
    3.         return true;
    4.     }
    5.  
    6.     public void push(E e) {
    7.         addFirst(e);
    8.     }

    2）增加尾节点

    1.     public boolean add(E e) {
    2.         //内部调用linkLast方法
    3.         linkLast(e);
    4.         return true;
    5.     }
    6.  
    7.     //将元素链接到链表尾部
    8.     void linkLast(E e) {
    9.         //创建一个节点引用l，指向原尾节点
    10.         final Node l = last;
    11.         //创建新节点，前驱为当前尾节点，后继为null
    12.         final Node newNode = new Node<>(l, e, null);
    13.         //新的要插入的节点作为新的尾节点
    14.         last = newNode;
    15.  
    16.         //判断原尾节点是否为null，即原集合有没有节点数据
    17.         if (l == null)
    18.             //如果原尾节点为null，即原集合没有节点数据，那么将新节点同时也作为首节点
    19.             first = newNode;
    20.         else    
    21.             //如果原尾节点不为null，即原集合有节点数据，那么将原来尾节点的next引用指向新的尾节点
    22.             l.next = newNode;
    23.         //节点数自增1
    24.         size++;
    25.         //结构改变的次数自增1
    26.         modCount++;
    27.     }

    其他添加到尾部的方法，原理都是一样的：

    1.     public void addLast(E e) {
    2.         linkLast(e);
    3.     }
    4.  
    5.     public boolean offer(E e) {
    6.         return add(e);
    7.     }
    8.  
    9.     public boolean offerLast(E e) {
    10.         addLast(e);
    11.         return true;
    12.     }

    3）指定位置添加

    1.     //在index前插入节点
    2.     public void add(int index, E element) {
    3.         //检查索引是否处于[0-size]之间
    4.         checkPositionIndex(index);
    5.  
    6.         //判断索引index是否等于size
    7.         if (index == size)
    8.             //如果索引index等于size，那实际上就是添加在链表尾部
    9.             linkLast(element);
    10.         else
    11.             //如果不等，调用linkBefore方法
    12.             linkBefore(element, node(index));
    13.     }
    14.  
    15.     //检查索引的方法
    16.     private void checkPositionIndex(int index) {
    17.         if (!isPositionIndex(index))
    18.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    19.     }
    20.  
    21.     //索引是否大于等于0，且小于等于size
    22.     private boolean isPositionIndex(int index) {
    23.         return index >= 0 && index <= size;
    24.     }
    1.     //在 指定节点 前插入一个元素，这里 指定节点对象不为 null
    2.     void linkBefore(E e, Node succ) {
    3.         // 获取指定节点 succ 前面的一个节点
    4.         final Node pred = succ.prev;
    5.         // 创建新节点，头部指向 succ 前面的节点，尾部指向 succ 节点，
    6.         final Node newNode = new Node<>(pred, e, succ);
    7.         //让 succ 节点头部指向 新建的节点
    8.         succ.prev = newNode;
    9.         //如果 succ 前面的节点为空，说明 succ 就是第一个节点，新建的节点就变成第一个节点了
    10.         if (pred == null)
    11.             first = newNode;
    12.         else
    13.             //如果前面有节点，让前面的节点的下一个节点指向新节的点
    14.             pred.next = newNode;
    15.         //节点数自增1
    16.         size++;
    17.         //结构改变的次数自增1
    18.         modCount++;
    19.     }
    20.  
    21.     //获取对应索引处的Node节点
    22.     Node node(int index) {
    23.         //判断索引是否小于节点数量的一半，size >> 1是位运算，就是size/2的意思
    24.         if (index < (size >> 1)) {
    25.             //从链表头开始查找对应索引处的节点
    26.             Node x = first;
    27.             for (int i = 0; i < index; i++)
    28.                 x = x.next;
    29.             return x;
    30.         } else {
    31.             //从链表头开始查找对应索引处的节点
    32.             Node x = last;
    33.             for (int i = size - 1; i > index; i--)
    34.                 x = x.prev;
    35.             return x;
    36.         }
    37.     }

    从node节点查找的实现可以看出来，这里的索引的查找，是从头或者尾开始循环遍历查找，时间复杂度为O(n)，因此效率相对于ArrayLsit的O(1)的查找时间复杂度来说，效率比较低。 

    4）批量增加

    1.     //在index前批量插入节点
    2.     public boolean addAll(int index, Collection c) {
    3.         //检查索引是否处于[0-size]之间
    4.         checkPositionIndex(index);
    5.  
    6.         //将集合转换为数组
    7.         Object[] a = c.toArray();
    8.         int numNew = a.length;
    9.         if (numNew == 0)
    10.             return false;
    11.  
    12.         // 记录 index 处节点及其前驱
    13.         // 相当于原链表在 pred 处断开了
    14.         Node pred, succ;
    15.         //如果索引index等于size，那实际上就是添加在链表尾部
    16.         if (index == size) {
    17.             succ = null;
    18.             pred = last;
    19.         } else {
    20.             succ = node(index);
    21.             pred = succ.prev;
    22.         }
    23.  
    24.          // 在该节点前驱 pred 后链式增加集合里的元素
    25.         for (Object o : a) {
    26.             @SuppressWarnings("unchecked") E e = (E) o;
    27.             Node newNode = new Node<>(pred, e, null);
    28.             if (pred == null)
    29.                 first = newNode;
    30.             else
    31.                 pred.next = newNode;
    32.             pred = newNode;
    33.         }
    34.  
    35.         // 把两条链表合在一起
    36.         // succ 为空，设置 last 即可
    37.         if (succ == null) {
    38.             //尾节点为pred
    39.             last = pred;
    40.         } else {
    41.              // succ 不为空，进行两条链表的链接
    42.             pred.next = succ;
    43.             succ.prev = pred;
    44.         }
    45.  
    46.         //节点数增加numNew
    47.         size += numNew;
    48.         //结构改变的次数自增1
    49.         modCount++;
    50.         return true;
    51.     }

    5、删除元素

    1）删除头节点

    1.     //获取并移除此列表的头（第一个元素）。如果列表为null，则抛出NoSuchElementException异常。
    2.     public E remove() {
    3.         return removeFirst();
    4.     }
    5.  
    6.     //获取并移除此列表的头（第一个元素）。如果列表为null，则抛出NoSuchElementException异常。
    7.     public E removeFirst() {
    8.         final Node f = first;
    9.         if (f == null)
    10.             throw new NoSuchElementException();
    11.         return unlinkFirst(f);
    12.     }
    13.  
    14.     //获取并移除此列表的头（第一个元素）。
    15.     private E unlinkFirst(Node f) {
    16.         //获取该节点(头节点)的值
    17.         final E element = f.item;
    18.         //获取头结点的下一个节点
    19.         final Node next = f.next;
    20.  
    21.         // 相应数据item设为 null, next指向null, 从而之后GC清理
    22.         f.item = null;
    23.         f.next = null;
    24.         //使头节点引用指向下一个节点
    25.         first = next;
    26.  
    27.         //如果下一个节点为null，即只有一个元素，此时集合为空
    28.         if (next == null)
    29.             //那么尾节点的引用也置null
    30.             last = null;
    31.         else
    32.             //下一个节点不为null，将下一个节点作为头节点，并将下一个节点的prev引用置null
    33.             next.prev = null;
    34.         //节点数自减1
    35.         size--;
    36.         //结构改变的次数自增1
    37.         modCount++;
    38.         return element;
    39.     }

    其他移除头结点的方法，原理都是一样的： 

    1.     public E pollFirst() {
    2.         final Node f = first;
    3.         return (f == null) ? null : unlinkFirst(f);
    4.     }
    5.  
    6.     public E pop() {
    7.         return removeFirst();
    8.     }

    2）删除尾节点

    1.     //获取并移除此列表的尾（最后一个元素）。如果列表为null，则抛出NoSuchElementException异常。
    2.     public E removeLast() {
    3.         final Node l = last;
    4.         if (l == null)
    5.             throw new NoSuchElementException();
    6.         return unlinkLast(l);
    7.     }
    8.  
    9.     //获取并移除此列表的尾（最后一个元素）。
    10.     private E unlinkLast(Node l) {
    11.         //获取该节点(尾节点)的值
    12.         final E element = l.item;
    13.         //获取尾节点的上一个节点
    14.         final Node prev = l.prev;
    15.  
    16.         // 相应数据item设为 null, prev指向null, 从而之后GC清理
    17.         l.item = null;
    18.         l.prev = null;
    19.         last = prev;
    20.  
    21.         //如果上一个节点为null，即只有一个元素，此时集合为空
    22.         if (prev == null)
    23.             //那么头节点的引用也置null
    24.             first = null;
    25.         else
    26.             //上一个节点不为null，将上一个节点作为尾节点，并将上一个节点的next引用置null
    27.             prev.next = null;
    28.         //节点数自减1
    29.         size--;
    30.         //结构改变的次数自增1
    31.         modCount++;
    32.         return element;
    33.     }

    其他移除头结点的方法，原理都是一样的：  

    1.     public E pollLast() {
    2.         final Node l = last;
    3.         return (l == null) ? null : unlinkLast(l);
    4.     }

    3）指定位置移除

    1.     public E remove(int index) {
    2.         //索引检查
    3.         checkElementIndex(index);
    4.         //注意这里和指定位置添加元素时检查的索引范围不一样，删除是[0,size),添加是[0,size]
    5.         return unlink(node(index));
    6.     }
    7.  
    8.     //取消链接非空节点 x
    9.     E unlink(Node x) {
    10.         // 获取该节点的值
    11.         final E element = x.item;
    12.         //创建节点引用next，指向该节点的下一个节点
    13.         final Node next = x.next;
    14.         //创建节点引用prev，指向该节点的上一个节点
    15.         final Node prev = x.prev;
    16.  
    17.         //判断该节点是否存在上一个节点
    18.         if (prev == null) {
    19.             //不存在上一个节点，则该节点为首节点，则让首节点引用指向该节点的下一个节点
    20.             first = next;
    21.         } else {
    22.             //存在上一个节点，则上一个节点的下一个节点引用指向该节点的下一个节点
    23.             prev.next = next;
    24.             //该节点的上一个节点的引用指向null
    25.             x.prev = null;
    26.         }
    27.  
    28.         //判断该节点是否存在下一个节点
    29.         if (next == null) {
    30.             //不存在下一个节点，则该节点为尾节点.则让尾节点引用指向该节点的上一个节点
    31.             last = prev;
    32.         } else {
    33.             //存在下一个节点，则下一个节点的上一个节点引用指向该节点的上一个节点
    34.             next.prev = prev;
    35.             //该节点的下一个节点的引用指向null
    36.             x.next = null;
    37.         }
    38.  
    39.         //该节点的值置空.此时没有任何引用指向该node节点对象,该对象将会被垃圾回器回收
    40.         x.item = null;
    41.         //节点数自减1
    42.         size--;
    43.         //结构改变的次数自增1
    44.         modCount++;
    45.         return element;
    46.     }

    4）删除指定数据

    1.     public boolean remove(Object o) {
    2.         if (o == null) {
    3.             for (Node x = first; x != null; x = x.next) {
    4.                 if (x.item == null) {
    5.                     unlink(x);
    6.                     return true;
    7.                 }
    8.             }
    9.         } else {
    10.             for (Node x = first; x != null; x = x.next) {
    11.                 if (o.equals(x.item)) {
    12.                     unlink(x);
    13.                     return true;
    14.                 }
    15.             }
    16.         }
    17.         return false;
    18.     }
    19.  
    20.  
    21.

    6、获取

    1）获取头节点的方法

    1.     //返回此列表的第一个元素。如果此列表为空，则抛出NoSuchElementException异常。
    2.     public E getFirst() {
    3.         final Node f = first;
    4.         if (f == null)
    5.             throw new NoSuchElementException();
    6.         return f.item;
    7.     }
    8.  
    9.     //获取但不移除此列表的头（第一个元素）。如果此列表为空，则返回null。
    10.     public E peek() {
    11.         final Node f = first;
    12.         return (f == null) ? null : f.item;
    13.     }
    14.  
    15.     //获取但不移除此列表的头（第一个元素）。如果此列表为空，则抛出NoSuchElementException异常。
    16.     public E element() {
    17.         return getFirst();
    18.     }
    19.  
    20.     //获取但不移除此列表的第一个元素；如果此列表为空，则返回null。
    21.     public E peekFirst() {
    22.         final Node f = first;
    23.         return (f == null) ? null : f.item;
    24.      }

    2）获取尾节点的方法

    1.     //返回此列表的最后一个元素。如果此列表为空，则抛出NoSuchElementException异常。
    2.     public E getLast() {
    3.         final Node l = last;
    4.         if (l == null)
    5.             throw new NoSuchElementException();
    6.         return l.item;
    7.     }
    8.     
    9.     //获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
    10.     public E peekLast() {
    11.         final Node l = last;
    12.         return (l == null) ? null : l.item;
    13.     }

    3）指定位置获取 

    1.     public E get(int index) {
    2.         //索引检查
    3.         checkElementIndex(index);
    4.         return node(index).item;
    5.     }

    7、contains和indexOf

    1.     //如果此列表包含指定元素，则返回 true。
    2.     public boolean contains(Object o) {
    3.         return indexOf(o) != -1;
    4.     }
    5.  
    6.     //返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
    7.     public int indexOf(Object o) {
    8.         int index = 0;
    9.          // o 为 null，直接比引用
    10.         if (o == null) {
    11.             for (Node x = first; x != null; x = x.next) {
    12.                 if (x.item == null)
    13.                     return index;
    14.                 index++;
    15.             }
    16.         // 否则，调用 equals
    17.         } else {
    18.             for (Node x = first; x != null; x = x.next) {
    19.                 if (o.equals(x.item))
    20.                     return index;
    21.                 index++;
    22.             }
    23.         }
    24.         return -1;
    25.     }
    26.  
    27.     //从后往前找
    28.     public int lastIndexOf(Object o) {
    29.         int index = size;
    30.         if (o == null) {
    31.             for (Node x = last; x != null; x = x.prev) {
    32.                 index--;
    33.                 if (x.item == null)
    34.                     return index;
    35.             }
    36.         } else {
    37.             for (Node x = last; x != null; x = x.prev) {
    38.                 index--;
    39.                 if (o.equals(x.item))
    40.                     return index;
    41.             }
    42.         }
    43.         return -1;
    44.     }

    8、克隆方法

    和大多数集合类一样，LinkedList的克隆方法并不会对数据进行克隆，算是浅克隆。

    1.     public Object clone() {
    2.         LinkedList clone = superClone();
    3.  
    4.         //清空克隆对象的内部变量引用值
    5.         clone.first = clone.last = null;
    6.         clone.size = 0;
    7.         clone.modCount = 0;
    8.  
    9.         /*
    10.         重新赋值
    12.         深克隆Node，这时新旧对象的Node是不一样了，但是对应索引的Node中的Item却还是浅克隆，
    13.         指向了同一个对象，改变对象的值会对两个链表都产生影响！
    15.         但是如果储存的是直接量则不会影响！
    16.         */
    17.         for (Node x = first; x != null; x = x.next)
    18.             clone.add(x.item);
    19.  
    20.         return clone;
    21.     }
    22.  
    23.     private LinkedList superClone() {
    24.         try {
    25.             //Object的clone方法
    26.             return (LinkedList) super.clone();
    27.         } catch (CloneNotSupportedException e) {
    28.             throw new InternalError(e);
    29.         }
    30.     }

    9、clear方法

    1.     public void clear() {
    2.         //手动清理全部链表节点之间的引用关系,帮助GC
    3.         for (Node x = first; x != null; ) {
    4.             Node next = x.next;
    5.             x.item = null;
    6.             x.next = null;
    7.             x.prev = null;
    8.             x = next;
    9.         }
    10.         //最后将外部的头\尾节点引用置空
    11.         first = last = null;
    12.         //size置0
    13.         size = 0;
    14.         //结构改变的次数自增1
    15.         modCount++;
    16.     }

    10、迭代器

    1）迭代器的结构

    1.     private class ListItr implements ListIterator {
    2.         // 最后被返回的节点的
    3.         private Node lastReturned;
    4.          // 下一个被返回的节点
    5.         private Node next;
    6.         // 下一个被返回的节点的索引
    7.         private int nextIndex;
    8.         // 用于检测并发修改异常
    9.         private int expectedModCount = modCount;
    10.  
    11.         ListItr(int index) {
    12.             //根据index设置下一个要被返回的节点
    13.             next = (index == size) ? null : node(index);
    14.             //根据index设置下一个要被返回的节点的索引
    15.             nextIndex = index;
    16.         }
    17. }

    2）checkForComodification函数

    判断是否存在并发修改异常

    1.     final void checkForComodification() {
    2.         if (modCount != expectedModCount)
    3.             throw new ConcurrentModificationException();
    4.     }

     3）next 函数

    用于正序遍历

    1.     public E next() {
    2.         //检测并发修改异常
    3.         checkForComodification();
    4.         //检测是否还存在可以获取的节点
    5.         if (!hasNext())
    6.             throw new NoSuchElementException();
    7.  
    8.         //设置 next,nextIndex 和 lastReturned 的值
    9.         lastReturned = next;
    10.         next = next.next;
    11.         nextIndex++;
    12.  
    13.         return lastReturned.item;
    14.     }
    15.  
    16.     //是否具有下一个节点
    17.     public boolean hasNext() {
    18.         return nextIndex < size;
    19.     }

    4）previous函数

     用于倒序遍历

    1.     public E previous() {
    2.         checkForComodification();
    3.         if (!hasPrevious())
    4.             throw new NoSuchElementException();
    5.  
    6.         //注意这里，next和lastReturned设置的是一个值
    7.         //在remove方法里会有应用
    8.         lastReturned = next = (next == null) ? last : next.prev;
    9.         nextIndex--;
    10.         return lastReturned.item;
    11.     }
    12.  
    13.     public boolean hasPrevious() {
    14.         return nextIndex > 0;
    15.     }

    4）调用原 LinkedList 的增删函数

    1.     public void add(E e) {
    2.         //检测并发修改异常
    3.         checkForComodification();
    4.         lastReturned = null;
    5.         if (next == null)
    6.             //尾部添加
    7.             linkLast(e);
    8.         else
    9.             //next前面添加
    10.             linkBefore(e, next);
    11.         nextIndex++;
    12.         expectedModCount++;
    13.     }

    注意源码中倒序遍历与正序遍历的区别 

    1.     public void remove() {
    2.         //检测并发修改异常
    3.         checkForComodification();
    4.  
    5.         //检测最后被返回的节点是否为null，当创建了迭代器对象直接使用该方法时，lastReturned就指向null
    6.         //因此不能先于next()方法使用，也不能连续使用remove()方法
    7.         if (lastReturned == null)
    8.             throw new IllegalStateException();
    9.  
    10.         //获取最后被返回的节点的下一个节点
    11.         Node lastNext = lastReturned.next;
    12.         //移除lastReturned节点和链表之间的引用关系，后续的节点链接到原节点的位置
    13.         unlink(lastReturned);
    14.  
    15.         //这里说明一下，如果是倒序遍历，那么就会返回true，正序遍历就会返回false，
    16.         if (next == lastReturned)
    17.             next = lastNext;
    18.         else
    19.             nextIndex--;
    20.         lastReturned = null;
    21.         //调用原 LinkedList 的增删函数，会导致modCount++，所以这里要更新对应的expectedModCount
    22.         expectedModCount++;
    23.     }

    5）forEachRemaining函数

    对 next 以及之后的节点的 item 属性调用action.accept(next.item);进行操作

    1.     public void forEachRemaining(Consumersuper E> action) {
    2.         //判断action是否为null
    3.         Objects.requireNonNull(action);
    4.         while (modCount == expectedModCount && nextIndex < size) {
    5.             action.accept(next.item);
    6.             lastReturned = next;
    7.             next = next.next;
    8.             nextIndex++;
    9.         }
    10.         //检测并发修改异常
    11.         checkForComodification();
    12.     }
    13.  
    14.     public static  T requireNonNull(T obj) {
    15.         if (obj == null)
    16.             throw new NullPointerException();
    17.         return obj;
    18.     }

    四、总结

    总体来看 LinkedList 的源码并不复杂，基本都是双向链表的基本操作，大家感兴趣的可以看一下。

    参考文章：LinkedList源码深度解析以及迭代器机制【一万字】_刘Java的博客-CSDN博客_linkedlist迭代器

    LinkedList 源码解析 - 掘金 (juejin.cn)

    LinkedList(JDK1.8)源码解析_ThinkWon的博客-CSDN博客​​​​​​​

  • 相关阅读:
    Flask——接口路由技术
    redis运维(十)列表
    springboot基础(79):通过pdf模板生成文件
    Spring如何使用环境变量控制配置文件加载呢?
    Java泛型方法与普通成员方法以及案例说明（五）
    vue keepAlive的使用
    《DevOps实践指南》- 读书笔记（二）
    Linux文件系统 struct dentry 结构体解析
    leetcode日记（32）字符串相乘
    数据结构：栈
  • 原文地址：https://blog.csdn.net/qq_51409098/article/details/127536826