上篇我们分析了ArrayList的底层实现，知道了ArrayList底层是基于数组实现的，因此具有查找修改快而插入删除慢的特点。本篇介绍的LinkedList是List接口的另一种实现，它的底层是基于双向链表实现的，因此它具有插入删除快而查找修改慢的特点，此外，通过对双向链表的操作还可以实现队列和栈的功能。LinkedList的底层结构如下图所示。

F表示头结点引用，L表示尾结点引用，链表的每个结点都有三个元素，分别是前继结点引用(P)，结点元素的值(E)，后继结点的引用(N)。结点由内部类Node表示，我们看看它的内部结构。

  1. //结点内部类
  2. private static class Node<E> {
  3.     E item;          //元素
  4.     Node<E> next;    //下一个节点
  5.     Node<E> prev;    //上一个节点
  7.     Node(Node<E> prev, E element, Node<E> next) {
  8.         this.item = element;
  9.         this.next = next;
  10.         this.prev = prev;
  11.     }
  12. }

Node这个内部类其实很简单，只有三个成员变量和一个构造器，item表示结点的值，next为下一个结点的引用，prev为上一个结点的引用，通过构造器传入这三个值。接下来再看看LinkedList的成员变量和构造器。

  1. //集合元素个数
  2. transient int size = 0;
  4. //头结点引用
  5. transient Node<E> first;
  7. //尾节点引用
  8. transient Node<E> last;
  10. //无参构造器
  11. public LinkedList() {}
  13. //传入外部集合的构造器
  14. public LinkedList(Collection<? extends E> c) {
  15.     this();
  16.     addAll(c);
  17. }

LinkedList持有头结点的引用和尾结点的引用，它有两个构造器，一个是无参构造器，一个是传入外部集合的构造器。与ArrayList不同的是LinkedList没有指定初始大小的构造器。看看它的增删改查方法。

  1. //增(添加)
  2. public boolean add(E e) {
  3.     //在链表尾部添加
  4.     linkLast(e);
  5.     return true;
  6. }
  8. //增(插入)
  9. public void add(int index, E element) {
  10. 		//判定index位置的合法性,index >= 0 && index <= size才可以
  11.     checkPositionIndex(index);
  12.     //如果插入的index等于size,则表示index是最后一个
  13.     if (index == size) {
  14.         //在链表尾部添加
  15.         linkLast(element);
  16.     } else {
  17.         //在链表中部插入
  18.         //传入的参数为当前的值element和index处的节点node(index)
  19.         linkBefore(element, node(index));
  20.     }
  21. }
  23. //删(给定下标)
  24. public E remove(int index) {
  25.     //检查下标是否合法,index >= 0 && index <= size才可以
  26.     checkElementIndex(index);
  27.     //unlink方法的参数是index处的节点
  28.     return unlink(node(index));
  29. }
  31. //删(给定元素)
  32. public boolean remove(Object o) {
  33.     if (o == null) {
  34.     		//遍历整个链表删除
  35.         for (Node<E> x = first; x != null; x = x.next) {
  36.             if (x.item == null) {
  37.                 unlink(x);
  38.                 return true;
  39.             }
  40.         }
  41.     } else {
  42.         //遍历整个链表删除
  43.         for (Node<E> x = first; x != null; x = x.next) {
  44.             if (o.equals(x.item)) {
  45.                 //找到了就删除
  46.                 unlink(x);
  47.                 return true;
  48.             }
  49.         }
  50.     }
  51.     return false;
  52. }
  54. //改
  55. public E set(int index, E element) {
  56.     //检查下标是否合法
  57.     checkElementIndex(index);
  58.     //获取指定下标的结点引用
  59.     Node<E> x = node(index);
  60.     //获取指定下标结点的值
  61.     E oldVal = x.item;
  62.     //将结点元素设置为新的值
  63.     x.item = element;
  64.     //返回之前的值
  65.     return oldVal;
  66. }
  68. //查
  69. public E get(int index) {
  70.     //检查下标是否合法
  71.     checkElementIndex(index);
  72.     //返回指定下标的结点的值
  73.     return node(index).item;
  74. }

插入节点的具体方法

  1. //链接到指定结点之前
  2. void linkBefore(E e, Node<E> succ) {
  3.     //获取给定结点的上一个结点引用
  4.     final Node<E> pred = succ.prev;
  5.     //创建新结点, 新结点的上一个结点引用指向给定结点的上一个结点
  6.     //新结点的下一个结点的引用指向给定的结点
  7.     final Node<E> newNode = new Node<>(pred, e, succ);
  8.     //将给定结点的上一个结点引用指向新结点
  9.     succ.prev = newNode;
  10.     //如果给定结点的上一个结点为空, 表明给定结点为头结点
  11.     if (pred == null) {
  12.         //将头结点引用指向新结点
  13.         first = newNode;
  14.     } else {
  15.         //否则, 将给定结点的上一个结点的下一个结点引用指向新结点
  16.         pred.next = newNode;
  17.     }
  18.     //集合元素个数加一
  19.     size++;
  20.     //修改次数加一
  21.     modCount++;
  22. }
  24. //卸载指定结点
  25. E unlink(Node<E> x) {
  26.     //获取给定结点的元素
  27.     final E element = x.item;
  28.     //获取给定结点的下一个结点的引用
  29.     final Node<E> next = x.next;
  30.     //获取给定结点的上一个结点的引用
  31.     final Node<E> prev = x.prev;
  33.     //如果给定结点的上一个结点为空, 说明给定结点为头结点
  34.     if (prev == null) {
  35.         //将头结点引用指向给定结点的下一个结点
  36.         first = next;
  37.     } else {
  38.         //将上一个结点的后继结点引用指向给定结点的后继结点
  39.         prev.next = next;
  40.         //将给定结点的上一个结点置空
  41.         x.prev = null;
  42.     }
  44.     //如果给定结点的下一个结点为空, 说明给定结点为尾结点
  45.     if (next == null) {
  46.         //将尾结点引用指向给定结点的上一个结点
  47.         last = prev;
  48.     } else {
  49.         //将下一个结点的前继结点引用指向给定结点的前继结点
  50.         next.prev = prev;
  51.         x.next = null;
  52.     }
  54.     //将给定结点的元素置空
  55.     x.item = null;
  56.     //集合元素个数减一
  57.     size--;
  58.     //修改次数加一
  59.     modCount++;
  60.     return element;
  61. }

linkBefore和unlink是具有代表性的链接结点和卸载结点的操作，其他的链接和卸载两端结点的方法与此类似，所以我们重点介绍linkBefore和unlink方法。

linkBefore方法的过程图：

unlink方法的过程图:

通过上面图示看到对链表的插入和删除操作的时间复杂度都是O(1)，而对链表的查找和修改操作都需要遍历链表进行元素的定位，这两个操作都是调用的node(int index)方法定位元素，看看它是怎样通过下标来定位元素的。

  1. //根据指定位置获取结点
  2. Node<E> node(int index) {
  3.     //如果下标在链表前半部分, 就从头开始查起.size >> 1值为size/2
  4.     if (index < (size >> 1)) {
  5.         Node<E> x = first;
  6.         for (int i = 0; i < index; i++) {
  7.             x = x.next;
  8.         }
  9.         return x;
  10.     } else {
  11.         //如果下标在链表后半部分, 就从尾开始查起
  12.         Node<E> x = last;
  13.         for (int i = size - 1; i > index; i--) {
  14.             x = x.prev;
  15.         }
  16.         return x;
  17.     }
  18. }

通过下标定位时先判断是在链表的上半部分还是下半部分，如果是在上半部分就从头开始找起，如果是下半部分就从尾开始找起，因此通过下标的查找和修改操作的时间复杂度是O(n/2)。通过对双向链表的操作还可以实现单项队列，双向队列和栈的功能。

单向队列操作：

  1. //获取头结点
  2. public E peek() {
  3.     final Node<E> f = first;
  4.     return (f == null) ? null : f.item;
  5. }
  7. //获取头结点
  8. public E element() {
  9.     return getFirst();
  10. }
  12. //弹出头结点
  13. public E poll() {
  14.     final Node<E> f = first;
  15.     return (f == null) ? null : unlinkFirst(f);
  16. }
  18. //移除头结点
  19. public E remove() {
  20.     return removeFirst();
  21. }
  23. //在队列尾部添加结点
  24. public boolean offer(E e) {
  25.     return add(e);
  26. }

双向队列操作：

  1. //在头部添加
  2. public boolean offerFirst(E e) {
  3.     addFirst(e);
  4.     return true;
  5. }
  7. //在尾部添加
  8. public boolean offerLast(E e) {
  9.     addLast(e);
  10.     return true;
  11. }
  13. //获取头结点
  14. public E peekFirst() {
  15.     final Node<E> f = first;
  16.     return (f == null) ? null : f.item;
  17.  }
  19. //获取尾结点
  20. public E peekLast() {
  21.     final Node<E> l = last;
  22.     return (l == null) ? null : l.item;
  23. }

栈操作：

  1. //入栈
  2. public void push(E e) {
  3.     addFirst(e);
  4. }
  6. //出栈
  7. public E pop() {
  8.     return removeFirst();
  9. }

不管是单向队列还是双向队列还是栈，其实都是对链表的头结点和尾结点进行操作，它们的实现都是基于addFirst()，addLast()，removeFirst()，removeLast()这四个方法，它们的操作和linkBefore()和unlink()类似，只不过一个是对链表两端操作，一个是对链表中间操作。可以说这四个方法都是linkBefore()和unlink()方法的特殊情况，因此不难理解它们的内部实现，在此不多做介绍。

到这里，我们对LinkedList的分析也即将结束，对全文中的重点做个总结：

  1. 1. LinkedList是基于双向链表实现的，不论是增删改查方法还是队列和栈的实现，都可通过操作结点实现
  3. 2. LinkedList无需提前指定容量，因为基于链表操作，集合的容量随着元素的加入自动增加
  5. 3. LinkedList删除元素后集合占用的内存自动缩小，无需像ArrayList一样调用trimToSize()方法
  7. 4. LinkedList的所有方法没有进行同步，因此它也不是线程安全的，应该避免在多线程环境下使用
  9. 5. 以上分析基于JDK1.8，其他版本会有些出入，因此不能一概而论

LinkedList源码JDK1.8

  1. /*
  2.  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
  3.  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  4.  *
  5.  *
  6.  *
  7.  *
  8.  *
  9.  *
  10.  *
  11.  *
  12.  *
  13.  *
  14.  *
  15.  *
  16.  *
  17.  *
  18.  *
  19.  *
  20.  *
  21.  *
  22.  *
  23.  *
  24.  */
  26. package java.util;
  28. import java.util.function.Consumer;
  30. /**
  31.  * Doubly-linked list implementation of the {@code List} and {@code Deque}
  32.  * interfaces.  Implements all optional list operations, and permits all
  33.  * elements (including {@code null}).
  34.  *
  35.  * <p>All of the operations perform as could be expected for a doubly-linked
  36.  * list.  Operations that index into the list will traverse the list from
  37.  * the beginning or the end, whichever is closer to the specified index.
  38.  *
  39.  * <p><strong>Note that this implementation is not synchronized.</strong>
  40.  * If multiple threads access a linked list concurrently, and at least
  41.  * one of the threads modifies the list structurally, it <i>must</i> be
  42.  * synchronized externally.  (A structural modification is any operation
  43.  * that adds or deletes one or more elements; merely setting the value of
  44.  * an element is not a structural modification.)  This is typically
  45.  * accomplished by synchronizing on some object that naturally
  46.  * encapsulates the list.
  47.  *
  48.  * If no such object exists, the list should be "wrapped" using the
  49.  * {@link Collections#synchronizedList Collections.synchronizedList}
  50.  * method.  This is best done at creation time, to prevent accidental
  51.  * unsynchronized access to the list:<pre>
  52.  *   List list = Collections.synchronizedList(new LinkedList(...));</pre>
  53.  *
  54.  * <p>The iterators returned by this class's {@code iterator} and
  55.  * {@code listIterator} methods are <i>fail-fast</i>: if the list is
  56.  * structurally modified at any time after the iterator is created, in
  57.  * any way except through the Iterator's own {@code remove} or
  58.  * {@code add} methods, the iterator will throw a {@link
  59.  * ConcurrentModificationException}.  Thus, in the face of concurrent
  60.  * modification, the iterator fails quickly and cleanly, rather than
  61.  * risking arbitrary, non-deterministic behavior at an undetermined
  62.  * time in the future.
  63.  *
  64.  * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
  65.  * as it is, generally speaking, impossible to make any hard guarantees in the
  66.  * presence of unsynchronized concurrent modification.  Fail-fast iterators
  67.  * throw {@code ConcurrentModificationException} on a best-effort basis.
  68.  * Therefore, it would be wrong to write a program that depended on this
  69.  * exception for its correctness:   <i>the fail-fast behavior of iterators
  70.  * should be used only to detect bugs.</i>
  71.  *
  72.  * <p>This class is a member of the
  73.  * <a href="{@docRoot}/../technotes/guides/collections/index.html">
  74.  * Java Collections Framework</a>.
  75.  *
  76.  * @author  Josh Bloch
  77.  * @see     List
  78.  * @see     ArrayList
  79.  * @since 1.2
  80.  * @param <E> the type of elements held in this collection
  81.  */
  83. public class LinkedList<E>
  84.     extends AbstractSequentialList<E>
  85.     implements List<E>, Deque<E>, Cloneable, java.io.Serializable
  86. {
  87.     transient int size = 0;
  89.     /**
  90.      * Pointer to first node.
  91.      * Invariant: (first == null && last == null) ||
  92.      *            (first.prev == null && first.item != null)
  93.      */
  94.     transient Node<E> first;
  96.     /**
  97.      * Pointer to last node.
  98.      * Invariant: (first == null && last == null) ||
  99.      *            (last.next == null && last.item != null)
  100.      */
  101.     transient Node<E> last;
  103.     /**
  104.      * Constructs an empty list.
  105.      */
  106.     public LinkedList() {
  107.     }
  109.     /**
  110.      * Constructs a list containing the elements of the specified
  111.      * collection, in the order they are returned by the collection's
  112.      * iterator.
  113.      *
  114.      * @param  c the collection whose elements are to be placed into this list
  115.      * @throws NullPointerException if the specified collection is null
  116.      */
  117.     public LinkedList(Collection<? extends E> c) {
  118.         this();
  119.         addAll(c);
  120.     }
  122.     /**
  123.      * Links e as first element.
  124.      */
  125.     private void linkFirst(E e) {
  126.         final Node<E> f = first;
  127.         final Node<E> newNode = new Node<>(null, e, f);
  128.         first = newNode;
  129.         if (f == null)
  130.             last = newNode;
  131.         else
  132.             f.prev = newNode;
  133.         size++;
  134.         modCount++;
  135.     }
  137.     /**
  138.      * Links e as last element.
  139.      */
  140.     void linkLast(E e) {
  141.         final Node<E> l = last;
  142.         final Node<E> newNode = new Node<>(l, e, null);
  143.         last = newNode;
  144.         if (l == null)
  145.             first = newNode;
  146.         else
  147.             l.next = newNode;
  148.         size++;
  149.         modCount++;
  150.     }
  152.     /**
  153.      * Inserts element e before non-null Node succ.
  154.      */
  155.     void linkBefore(E e, Node<E> succ) {
  156.         // assert succ != null;
  157.         final Node<E> pred = succ.prev;
  158.         final Node<E> newNode = new Node<>(pred, e, succ);
  159.         succ.prev = newNode;
  160.         if (pred == null)
  161.             first = newNode;
  162.         else
  163.             pred.next = newNode;
  164.         size++;
  165.         modCount++;
  166.     }
  168.     /**
  169.      * Unlinks non-null first node f.
  170.      */
  171.     private E unlinkFirst(Node<E> f) {
  172.         // assert f == first && f != null;
  173.         final E element = f.item;
  174.         final Node<E> next = f.next;
  175.         f.item = null;
  176.         f.next = null; // help GC
  177.         first = next;
  178.         if (next == null)
  179.             last = null;
  180.         else
  181.             next.prev = null;
  182.         size--;
  183.         modCount++;
  184.         return element;
  185.     }
  187.     /**
  188.      * Unlinks non-null last node l.
  189.      */
  190.     private E unlinkLast(Node<E> l) {
  191.         // assert l == last && l != null;
  192.         final E element = l.item;
  193.         final Node<E> prev = l.prev;
  194.         l.item = null;
  195.         l.prev = null; // help GC
  196.         last = prev;
  197.         if (prev == null)
  198.             first = null;
  199.         else
  200.             prev.next = null;
  201.         size--;
  202.         modCount++;
  203.         return element;
  204.     }
  206.     /**
  207.      * Unlinks non-null node x.
  208.      */
  209.     E unlink(Node<E> x) {
  210.         // assert x != null;
  211.         final E element = x.item;
  212.         final Node<E> next = x.next;
  213.         final Node<E> prev = x.prev;
  215.         if (prev == null) {
  216.             first = next;
  217.         } else {
  218.             prev.next = next;
  219.             x.prev = null;
  220.         }
  222.         if (next == null) {
  223.             last = prev;
  224.         } else {
  225.             next.prev = prev;
  226.             x.next = null;
  227.         }
  229.         x.item = null;
  230.         size--;
  231.         modCount++;
  232.         return element;
  233.     }
  235.     /**
  236.      * Returns the first element in this list.
  237.      *
  238.      * @return the first element in this list
  239.      * @throws NoSuchElementException if this list is empty
  240.      */
  241.     public E getFirst() {
  242.         final Node<E> f = first;
  243.         if (f == null)
  244.             throw new NoSuchElementException();
  245.         return f.item;
  246.     }
  248.     /**
  249.      * Returns the last element in this list.
  250.      *
  251.      * @return the last element in this list
  252.      * @throws NoSuchElementException if this list is empty
  253.      */
  254.     public E getLast() {
  255.         final Node<E> l = last;
  256.         if (l == null)
  257.             throw new NoSuchElementException();
  258.         return l.item;
  259.     }
  261.     /**
  262.      * Removes and returns the first element from this list.
  263.      *
  264.      * @return the first element from this list
  265.      * @throws NoSuchElementException if this list is empty
  266.      */
  267.     public E removeFirst() {
  268.         final Node<E> f = first;
  269.         if (f == null)
  270.             throw new NoSuchElementException();
  271.         return unlinkFirst(f);
  272.     }
  274.     /**
  275.      * Removes and returns the last element from this list.
  276.      *
  277.      * @return the last element from this list
  278.      * @throws NoSuchElementException if this list is empty
  279.      */
  280.     public E removeLast() {
  281.         final Node<E> l = last;
  282.         if (l == null)
  283.             throw new NoSuchElementException();
  284.         return unlinkLast(l);
  285.     }
  287.     /**
  288.      * Inserts the specified element at the beginning of this list.
  289.      *
  290.      * @param e the element to add
  291.      */
  292.     public void addFirst(E e) {
  293.         linkFirst(e);
  294.     }
  296.     /**
  297.      * Appends the specified element to the end of this list.
  298.      *
  299.      * <p>This method is equivalent to {@link #add}.
  300.      *
  301.      * @param e the element to add
  302.      */
  303.     public void addLast(E e) {
  304.         linkLast(e);
  305.     }
  307.     /**
  308.      * Returns {@code true} if this list contains the specified element.
  309.      * More formally, returns {@code true} if and only if this list contains
  310.      * at least one element {@code e} such that
  311.      * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
  312.      *
  313.      * @param o element whose presence in this list is to be tested
  314.      * @return {@code true} if this list contains the specified element
  315.      */
  316.     public boolean contains(Object o) {
  317.         return indexOf(o) != -1;
  318.     }
  320.     /**
  321.      * Returns the number of elements in this list.
  322.      *
  323.      * @return the number of elements in this list
  324.      */
  325.     public int size() {
  326.         return size;
  327.     }
  329.     /**
  330.      * Appends the specified element to the end of this list.
  331.      *
  332.      * <p>This method is equivalent to {@link #addLast}.
  333.      *
  334.      * @param e element to be appended to this list
  335.      * @return {@code true} (as specified by {@link Collection#add})
  336.      */
  337.     public boolean add(E e) {
  338.         linkLast(e);
  339.         return true;
  340.     }
  342.     /**
  343.      * Removes the first occurrence of the specified element from this list,
  344.      * if it is present.  If this list does not contain the element, it is
  345.      * unchanged.  More formally, removes the element with the lowest index
  346.      * {@code i} such that
  347.      * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
  348.      * (if such an element exists).  Returns {@code true} if this list
  349.      * contained the specified element (or equivalently, if this list
  350.      * changed as a result of the call).
  351.      *
  352.      * @param o element to be removed from this list, if present
  353.      * @return {@code true} if this list contained the specified element
  354.      */
  355.     public boolean remove(Object o) {
  356.         if (o == null) {
  357.             for (Node<E> x = first; x != null; x = x.next) {
  358.                 if (x.item == null) {
  359.                     unlink(x);
  360.                     return true;
  361.                 }
  362.             }
  363.         } else {
  364.             for (Node<E> x = first; x != null; x = x.next) {
  365.                 if (o.equals(x.item)) {
  366.                     unlink(x);
  367.                     return true;
  368.                 }
  369.             }
  370.         }
  371.         return false;
  372.     }
  374.     /**
  375.      * Appends all of the elements in the specified collection to the end of
  376.      * this list, in the order that they are returned by the specified
  377.      * collection's iterator.  The behavior of this operation is undefined if
  378.      * the specified collection is modified while the operation is in
  379.      * progress.  (Note that this will occur if the specified collection is
  380.      * this list, and it's nonempty.)
  381.      *
  382.      * @param c collection containing elements to be added to this list
  383.      * @return {@code true} if this list changed as a result of the call
  384.      * @throws NullPointerException if the specified collection is null
  385.      */
  386.     public boolean addAll(Collection<? extends E> c) {
  387.         return addAll(size, c);
  388.     }
  390.     /**
  391.      * Inserts all of the elements in the specified collection into this
  392.      * list, starting at the specified position.  Shifts the element
  393.      * currently at that position (if any) and any subsequent elements to
  394.      * the right (increases their indices).  The new elements will appear
  395.      * in the list in the order that they are returned by the
  396.      * specified collection's iterator.
  397.      *
  398.      * @param index index at which to insert the first element
  399.      *              from the specified collection
  400.      * @param c collection containing elements to be added to this list
  401.      * @return {@code true} if this list changed as a result of the call
  402.      * @throws IndexOutOfBoundsException {@inheritDoc}
  403.      * @throws NullPointerException if the specified collection is null
  404.      */
  405.     public boolean addAll(int index, Collection<? extends E> c) {
  406.         checkPositionIndex(index);
  408.         Object[] a = c.toArray();
  409.         int numNew = a.length;
  410.         if (numNew == 0)
  411.             return false;
  413.         Node<E> pred, succ;
  414.         if (index == size) {
  415.             succ = null;
  416.             pred = last;
  417.         } else {
  418.             succ = node(index);
  419.             pred = succ.prev;
  420.         }
  422.         for (Object o : a) {
  423.             @SuppressWarnings("unchecked") E e = (E) o;
  424.             Node<E> newNode = new Node<>(pred, e, null);
  425.             if (pred == null)
  426.                 first = newNode;
  427.             else
  428.                 pred.next = newNode;
  429.             pred = newNode;
  430.         }
  432.         if (succ == null) {
  433.             last = pred;
  434.         } else {
  435.             pred.next = succ;
  436.             succ.prev = pred;
  437.         }
  439.         size += numNew;
  440.         modCount++;
  441.         return true;
  442.     }
  444.     /**
  445.      * Removes all of the elements from this list.
  446.      * The list will be empty after this call returns.
  447.      */
  448.     public void clear() {
  449.         // Clearing all of the links between nodes is "unnecessary", but:
  450.         // - helps a generational GC if the discarded nodes inhabit
  451.         //   more than one generation
  452.         // - is sure to free memory even if there is a reachable Iterator
  453.         for (Node<E> x = first; x != null; ) {
  454.             Node<E> next = x.next;
  455.             x.item = null;
  456.             x.next = null;
  457.             x.prev = null;
  458.             x = next;
  459.         }
  460.         first = last = null;
  461.         size = 0;
  462.         modCount++;
  463.     }
  465.     // Positional Access Operations
  467.     /**
  468.      * Returns the element at the specified position in this list.
  469.      *
  470.      * @param index index of the element to return
  471.      * @return the element at the specified position in this list
  472.      * @throws IndexOutOfBoundsException {@inheritDoc}
  473.      */
  474.     public E get(int index) {
  475.         checkElementIndex(index);
  476.         return node(index).item;
  477.     }
  479.     /**
  480.      * Replaces the element at the specified position in this list with the
  481.      * specified element.
  482.      *
  483.      * @param index index of the element to replace
  484.      * @param element element to be stored at the specified position
  485.      * @return the element previously at the specified position
  486.      * @throws IndexOutOfBoundsException {@inheritDoc}
  487.      */
  488.     public E set(int index, E element) {
  489.         checkElementIndex(index);
  490.         Node<E> x = node(index);
  491.         E oldVal = x.item;
  492.         x.item = element;
  493.         return oldVal;
  494.     }
  496.     /**
  497.      * Inserts the specified element at the specified position in this list.
  498.      * Shifts the element currently at that position (if any) and any
  499.      * subsequent elements to the right (adds one to their indices).
  500.      *
  501.      * @param index index at which the specified element is to be inserted
  502.      * @param element element to be inserted
  503.      * @throws IndexOutOfBoundsException {@inheritDoc}
  504.      */
  505.     public void add(int index, E element) {
  506.         checkPositionIndex(index);
  508.         if (index == size)
  509.             linkLast(element);
  510.         else
  511.             linkBefore(element, node(index));
  512.     }
  514.     /**
  515.      * Removes the element at the specified position in this list.  Shifts any
  516.      * subsequent elements to the left (subtracts one from their indices).
  517.      * Returns the element that was removed from the list.
  518.      *
  519.      * @param index the index of the element to be removed
  520.      * @return the element previously at the specified position
  521.      * @throws IndexOutOfBoundsException {@inheritDoc}
  522.      */
  523.     public E remove(int index) {
  524.         checkElementIndex(index);
  525.         return unlink(node(index));
  526.     }
  528.     /**
  529.      * Tells if the argument is the index of an existing element.
  530.      */
  531.     private boolean isElementIndex(int index) {
  532.         return index >= 0 && index < size;
  533.     }
  535.     /**
  536.      * Tells if the argument is the index of a valid position for an
  537.      * iterator or an add operation.
  538.      */
  539.     private boolean isPositionIndex(int index) {
  540.         return index >= 0 && index <= size;
  541.     }
  543.     /**
  544.      * Constructs an IndexOutOfBoundsException detail message.
  545.      * Of the many possible refactorings of the error handling code,
  546.      * this "outlining" performs best with both server and client VMs.
  547.      */
  548.     private String outOfBoundsMsg(int index) {
  549.         return "Index: "+index+", Size: "+size;
  550.     }
  552.     private void checkElementIndex(int index) {
  553.         if (!isElementIndex(index))
  554.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  555.     }
  557.     private void checkPositionIndex(int index) {
  558.         if (!isPositionIndex(index))
  559.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  560.     }
  562.     /**
  563.      * Returns the (non-null) Node at the specified element index.
  564.      */
  565.     Node<E> node(int index) {
  566.         // assert isElementIndex(index);
  568.         if (index < (size >> 1)) {
  569.             Node<E> x = first;
  570.             for (int i = 0; i < index; i++)
  571.                 x = x.next;
  572.             return x;
  573.         } else {
  574.             Node<E> x = last;
  575.             for (int i = size - 1; i > index; i--)
  576.                 x = x.prev;
  577.             return x;
  578.         }
  579.     }
  581.     // Search Operations
  583.     /**
  584.      * Returns the index of the first occurrence of the specified element
  585.      * in this list, or -1 if this list does not contain the element.
  586.      * More formally, returns the lowest index {@code i} such that
  587.      * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
  588.      * or -1 if there is no such index.
  589.      *
  590.      * @param o element to search for
  591.      * @return the index of the first occurrence of the specified element in
  592.      *         this list, or -1 if this list does not contain the element
  593.      */
  594.     public int indexOf(Object o) {
  595.         int index = 0;
  596.         if (o == null) {
  597.             for (Node<E> x = first; x != null; x = x.next) {
  598.                 if (x.item == null)
  599.                     return index;
  600.                 index++;
  601.             }
  602.         } else {
  603.             for (Node<E> x = first; x != null; x = x.next) {
  604.                 if (o.equals(x.item))
  605.                     return index;
  606.                 index++;
  607.             }
  608.         }
  609.         return -1;
  610.     }
  612.     /**
  613.      * Returns the index of the last occurrence of the specified element
  614.      * in this list, or -1 if this list does not contain the element.
  615.      * More formally, returns the highest index {@code i} such that
  616.      * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
  617.      * or -1 if there is no such index.
  618.      *
  619.      * @param o element to search for
  620.      * @return the index of the last occurrence of the specified element in
  621.      *         this list, or -1 if this list does not contain the element
  622.      */
  623.     public int lastIndexOf(Object o) {
  624.         int index = size;
  625.         if (o == null) {
  626.             for (Node<E> x = last; x != null; x = x.prev) {
  627.                 index--;
  628.                 if (x.item == null)
  629.                     return index;
  630.             }
  631.         } else {
  632.             for (Node<E> x = last; x != null; x = x.prev) {
  633.                 index--;
  634.                 if (o.equals(x.item))
  635.                     return index;
  636.             }
  637.         }
  638.         return -1;
  639.     }
  641.     // Queue operations.
  643.     /**
  644.      * Retrieves, but does not remove, the head (first element) of this list.
  645.      *
  646.      * @return the head of this list, or {@code null} if this list is empty
  647.      * @since 1.5
  648.      */
  649.     public E peek() {
  650.         final Node<E> f = first;
  651.         return (f == null) ? null : f.item;
  652.     }
  654.     /**
  655.      * Retrieves, but does not remove, the head (first element) of this list.
  656.      *
  657.      * @return the head of this list
  658.      * @throws NoSuchElementException if this list is empty
  659.      * @since 1.5
  660.      */
  661.     public E element() {
  662.         return getFirst();
  663.     }
  665.     /**
  666.      * Retrieves and removes the head (first element) of this list.
  667.      *
  668.      * @return the head of this list, or {@code null} if this list is empty
  669.      * @since 1.5
  670.      */
  671.     public E poll() {
  672.         final Node<E> f = first;
  673.         return (f == null) ? null : unlinkFirst(f);
  674.     }
  676.     /**
  677.      * Retrieves and removes the head (first element) of this list.
  678.      *
  679.      * @return the head of this list
  680.      * @throws NoSuchElementException if this list is empty
  681.      * @since 1.5
  682.      */
  683.     public E remove() {
  684.         return removeFirst();
  685.     }
  687.     /**
  688.      * Adds the specified element as the tail (last element) of this list.
  689.      *
  690.      * @param e the element to add
  691.      * @return {@code true} (as specified by {@link Queue#offer})
  692.      * @since 1.5
  693.      */
  694.     public boolean offer(E e) {
  695.         return add(e);
  696.     }
  698.     // Deque operations
  699.     /**
  700.      * Inserts the specified element at the front of this list.
  701.      *
  702.      * @param e the element to insert
  703.      * @return {@code true} (as specified by {@link Deque#offerFirst})
  704.      * @since 1.6
  705.      */
  706.     public boolean offerFirst(E e) {
  707.         addFirst(e);
  708.         return true;
  709.     }
  711.     /**
  712.      * Inserts the specified element at the end of this list.
  713.      *
  714.      * @param e the element to insert
  715.      * @return {@code true} (as specified by {@link Deque#offerLast})
  716.      * @since 1.6
  717.      */
  718.     public boolean offerLast(E e) {
  719.         addLast(e);
  720.         return true;
  721.     }
  723.     /**
  724.      * Retrieves, but does not remove, the first element of this list,
  725.      * or returns {@code null} if this list is empty.
  726.      *
  727.      * @return the first element of this list, or {@code null}
  728.      *         if this list is empty
  729.      * @since 1.6
  730.      */
  731.     public E peekFirst() {
  732.         final Node<E> f = first;
  733.         return (f == null) ? null : f.item;
  734.      }
  736.     /**
  737.      * Retrieves, but does not remove, the last element of this list,
  738.      * or returns {@code null} if this list is empty.
  739.      *
  740.      * @return the last element of this list, or {@code null}
  741.      *         if this list is empty
  742.      * @since 1.6
  743.      */
  744.     public E peekLast() {
  745.         final Node<E> l = last;
  746.         return (l == null) ? null : l.item;
  747.     }
  749.     /**
  750.      * Retrieves and removes the first element of this list,
  751.      * or returns {@code null} if this list is empty.
  752.      *
  753.      * @return the first element of this list, or {@code null} if
  754.      *     this list is empty
  755.      * @since 1.6
  756.      */
  757.     public E pollFirst() {
  758.         final Node<E> f = first;
  759.         return (f == null) ? null : unlinkFirst(f);
  760.     }
  762.     /**
  763.      * Retrieves and removes the last element of this list,
  764.      * or returns {@code null} if this list is empty.
  765.      *
  766.      * @return the last element of this list, or {@code null} if
  767.      *     this list is empty
  768.      * @since 1.6
  769.      */
  770.     public E pollLast() {
  771.         final Node<E> l = last;
  772.         return (l == null) ? null : unlinkLast(l);
  773.     }
  775.     /**
  776.      * Pushes an element onto the stack represented by this list.  In other
  777.      * words, inserts the element at the front of this list.
  778.      *
  779.      * <p>This method is equivalent to {@link #addFirst}.
  780.      *
  781.      * @param e the element to push
  782.      * @since 1.6
  783.      */
  784.     public void push(E e) {
  785.         addFirst(e);
  786.     }
  788.     /**
  789.      * Pops an element from the stack represented by this list.  In other
  790.      * words, removes and returns the first element of this list.
  791.      *
  792.      * <p>This method is equivalent to {@link #removeFirst()}.
  793.      *
  794.      * @return the element at the front of this list (which is the top
  795.      *         of the stack represented by this list)
  796.      * @throws NoSuchElementException if this list is empty
  797.      * @since 1.6
  798.      */
  799.     public E pop() {
  800.         return removeFirst();
  801.     }
  803.     /**
  804.      * Removes the first occurrence of the specified element in this
  805.      * list (when traversing the list from head to tail).  If the list
  806.      * does not contain the element, it is unchanged.
  807.      *
  808.      * @param o element to be removed from this list, if present
  809.      * @return {@code true} if the list contained the specified element
  810.      * @since 1.6
  811.      */
  812.     public boolean removeFirstOccurrence(Object o) {
  813.         return remove(o);
  814.     }
  816.     /**
  817.      * Removes the last occurrence of the specified element in this
  818.      * list (when traversing the list from head to tail).  If the list
  819.      * does not contain the element, it is unchanged.
  820.      *
  821.      * @param o element to be removed from this list, if present
  822.      * @return {@code true} if the list contained the specified element
  823.      * @since 1.6
  824.      */
  825.     public boolean removeLastOccurrence(Object o) {
  826.         if (o == null) {
  827.             for (Node<E> x = last; x != null; x = x.prev) {
  828.                 if (x.item == null) {
  829.                     unlink(x);
  830.                     return true;
  831.                 }
  832.             }
  833.         } else {
  834.             for (Node<E> x = last; x != null; x = x.prev) {
  835.                 if (o.equals(x.item)) {
  836.                     unlink(x);
  837.                     return true;
  838.                 }
  839.             }
  840.         }
  841.         return false;
  842.     }
  844.     /**
  845.      * Returns a list-iterator of the elements in this list (in proper
  846.      * sequence), starting at the specified position in the list.
  847.      * Obeys the general contract of {@code List.listIterator(int)}.<p>
  848.      *
  849.      * The list-iterator is <i>fail-fast</i>: if the list is structurally
  850.      * modified at any time after the Iterator is created, in any way except
  851.      * through the list-iterator's own {@code remove} or {@code add}
  852.      * methods, the list-iterator will throw a
  853.      * {@code ConcurrentModificationException}.  Thus, in the face of
  854.      * concurrent modification, the iterator fails quickly and cleanly, rather
  855.      * than risking arbitrary, non-deterministic behavior at an undetermined
  856.      * time in the future.
  857.      *
  858.      * @param index index of the first element to be returned from the
  859.      *              list-iterator (by a call to {@code next})
  860.      * @return a ListIterator of the elements in this list (in proper
  861.      *         sequence), starting at the specified position in the list
  862.      * @throws IndexOutOfBoundsException {@inheritDoc}
  863.      * @see List#listIterator(int)
  864.      */
  865.     public ListIterator<E> listIterator(int index) {
  866.         checkPositionIndex(index);
  867.         return new ListItr(index);
  868.     }
  870.     private class ListItr implements ListIterator<E> {
  871.         private Node<E> lastReturned;
  872.         private Node<E> next;
  873.         private int nextIndex;
  874.         private int expectedModCount = modCount;
  876.         ListItr(int index) {
  877.             // assert isPositionIndex(index);
  878.             next = (index == size) ? null : node(index);
  879.             nextIndex = index;
  880.         }
  882.         public boolean hasNext() {
  883.             return nextIndex < size;
  884.         }
  886.         public E next() {
  887.             checkForComodification();
  888.             if (!hasNext())
  889.                 throw new NoSuchElementException();
  891.             lastReturned = next;
  892.             next = next.next;
  893.             nextIndex++;
  894.             return lastReturned.item;
  895.         }
  897.         public boolean hasPrevious() {
  898.             return nextIndex > 0;
  899.         }
  901.         public E previous() {
  902.             checkForComodification();
  903.             if (!hasPrevious())
  904.                 throw new NoSuchElementException();
  906.             lastReturned = next = (next == null) ? last : next.prev;
  907.             nextIndex--;
  908.             return lastReturned.item;
  909.         }
  911.         public int nextIndex() {
  912.             return nextIndex;
  913.         }
  915.         public int previousIndex() {
  916.             return nextIndex - 1;
  917.         }
  919.         public void remove() {
  920.             checkForComodification();
  921.             if (lastReturned == null)
  922.                 throw new IllegalStateException();
  924.             Node<E> lastNext = lastReturned.next;
  925.             unlink(lastReturned);
  926.             if (next == lastReturned)
  927.                 next = lastNext;
  928.             else
  929.                 nextIndex--;
  930.             lastReturned = null;
  931.             expectedModCount++;
  932.         }
  934.         public void set(E e) {
  935.             if (lastReturned == null)
  936.                 throw new IllegalStateException();
  937.             checkForComodification();
  938.             lastReturned.item = e;
  939.         }
  941.         public void add(E e) {
  942.             checkForComodification();
  943.             lastReturned = null;
  944.             if (next == null)
  945.                 linkLast(e);
  946.             else
  947.                 linkBefore(e, next);
  948.             nextIndex++;
  949.             expectedModCount++;
  950.         }
  952.         public void forEachRemaining(Consumer<? super E> action) {
  953.             Objects.requireNonNull(action);
  954.             while (modCount == expectedModCount && nextIndex < size) {
  955.                 action.accept(next.item);
  956.                 lastReturned = next;
  957.                 next = next.next;
  958.                 nextIndex++;
  959.             }
  960.             checkForComodification();
  961.         }
  963.         final void checkForComodification() {
  964.             if (modCount != expectedModCount)
  965.                 throw new ConcurrentModificationException();
  966.         }
  967.     }
  969.     private static class Node<E> {
  970.         E item;
  971.         Node<E> next;
  972.         Node<E> prev;
  974.         Node(Node<E> prev, E element, Node<E> next) {
  975.             this.item = element;
  976.             this.next = next;
  977.             this.prev = prev;
  978.         }
  979.     }
  981.     /**
  982.      * @since 1.6
  983.      */
  984.     public Iterator<E> descendingIterator() {
  985.         return new DescendingIterator();
  986.     }
  988.     /**
  989.      * Adapter to provide descending iterators via ListItr.previous
  990.      */
  991.     private class DescendingIterator implements Iterator<E> {
  992.         private final ListItr itr = new ListItr(size());
  993.         public boolean hasNext() {
  994.             return itr.hasPrevious();
  995.         }
  996.         public E next() {
  997.             return itr.previous();
  998.         }
  999.         public void remove() {
  1000.             itr.remove();
  1001.         }
  1002.     }
  1004.     @SuppressWarnings("unchecked")
  1005.     private LinkedList<E> superClone() {
  1006.         try {
  1007.             return (LinkedList<E>) super.clone();
  1008.         } catch (CloneNotSupportedException e) {
  1009.             throw new InternalError(e);
  1010.         }
  1011.     }
  1013.     /**
  1014.      * Returns a shallow copy of this {@code LinkedList}. (The elements
  1015.      * themselves are not cloned.)
  1016.      *
  1017.      * @return a shallow copy of this {@code LinkedList} instance
  1018.      */
  1019.     public Object clone() {
  1020.         LinkedList<E> clone = superClone();
  1022.         // Put clone into "virgin" state
  1023.         clone.first = clone.last = null;
  1024.         clone.size = 0;
  1025.         clone.modCount = 0;
  1027.         // Initialize clone with our elements
  1028.         for (Node<E> x = first; x != null; x = x.next)
  1029.             clone.add(x.item);
  1031.         return clone;
  1032.     }
  1034.     /**
  1035.      * Returns an array containing all of the elements in this list
  1036.      * in proper sequence (from first to last element).
  1037.      *
  1038.      * <p>The returned array will be "safe" in that no references to it are
  1039.      * maintained by this list.  (In other words, this method must allocate
  1040.      * a new array).  The caller is thus free to modify the returned array.
  1041.      *
  1042.      * <p>This method acts as bridge between array-based and collection-based
  1043.      * APIs.
  1044.      *
  1045.      * @return an array containing all of the elements in this list
  1046.      *         in proper sequence
  1047.      */
  1048.     public Object[] toArray() {
  1049.         Object[] result = new Object[size];
  1050.         int i = 0;
  1051.         for (Node<E> x = first; x != null; x = x.next)
  1052.             result[i++] = x.item;
  1053.         return result;
  1054.     }
  1056.     /**
  1057.      * Returns an array containing all of the elements in this list in
  1058.      * proper sequence (from first to last element); the runtime type of
  1059.      * the returned array is that of the specified array.  If the list fits
  1060.      * in the specified array, it is returned therein.  Otherwise, a new
  1061.      * array is allocated with the runtime type of the specified array and
  1062.      * the size of this list.
  1063.      *
  1064.      * <p>If the list fits in the specified array with room to spare (i.e.,
  1065.      * the array has more elements than the list), the element in the array
  1066.      * immediately following the end of the list is set to {@code null}.
  1067.      * (This is useful in determining the length of the list <i>only</i> if
  1068.      * the caller knows that the list does not contain any null elements.)
  1069.      *
  1070.      * <p>Like the {@link #toArray()} method, this method acts as bridge between
  1071.      * array-based and collection-based APIs.  Further, this method allows
  1072.      * precise control over the runtime type of the output array, and may,
  1073.      * under certain circumstances, be used to save allocation costs.
  1074.      *
  1075.      * <p>Suppose {@code x} is a list known to contain only strings.
  1076.      * The following code can be used to dump the list into a newly
  1077.      * allocated array of {@code String}:
  1078.      *
  1079.      * <pre>
  1080.      *     String[] y = x.toArray(new String[0]);</pre>
  1081.      *
  1082.      * Note that {@code toArray(new Object[0])} is identical in function to
  1083.      * {@code toArray()}.
  1084.      *
  1085.      * @param a the array into which the elements of the list are to
  1086.      *          be stored, if it is big enough; otherwise, a new array of the
  1087.      *          same runtime type is allocated for this purpose.
  1088.      * @return an array containing the elements of the list
  1089.      * @throws ArrayStoreException if the runtime type of the specified array
  1090.      *         is not a supertype of the runtime type of every element in
  1091.      *         this list
  1092.      * @throws NullPointerException if the specified array is null
  1093.      */
  1094.     @SuppressWarnings("unchecked")
  1095.     public <T> T[] toArray(T[] a) {
  1096.         if (a.length < size)
  1097.             a = (T[])java.lang.reflect.Array.newInstance(
  1098.                                 a.getClass().getComponentType(), size);
  1099.         int i = 0;
  1100.         Object[] result = a;
  1101.         for (Node<E> x = first; x != null; x = x.next)
  1102.             result[i++] = x.item;
  1104.         if (a.length > size)
  1105.             a[size] = null;
  1107.         return a;
  1108.     }
  1110.     private static final long serialVersionUID = 876323262645176354L;
  1112.     /**
  1113.      * Saves the state of this {@code LinkedList} instance to a stream
  1114.      * (that is, serializes it).
  1115.      *
  1116.      * @serialData The size of the list (the number of elements it
  1117.      *             contains) is emitted (int), followed by all of its
  1118.      *             elements (each an Object) in the proper order.
  1119.      */
  1120.     private void writeObject(java.io.ObjectOutputStream s)
  1121.         throws java.io.IOException {
  1122.         // Write out any hidden serialization magic
  1123.         s.defaultWriteObject();
  1125.         // Write out size
  1126.         s.writeInt(size);
  1128.         // Write out all elements in the proper order.
  1129.         for (Node<E> x = first; x != null; x = x.next)
  1130.             s.writeObject(x.item);
  1131.     }
  1133.     /**
  1134.      * Reconstitutes this {@code LinkedList} instance from a stream
  1135.      * (that is, deserializes it).
  1136.      */
  1137.     @SuppressWarnings("unchecked")
  1138.     private void readObject(java.io.ObjectInputStream s)
  1139.         throws java.io.IOException, ClassNotFoundException {
  1140.         // Read in any hidden serialization magic
  1141.         s.defaultReadObject();
  1143.         // Read in size
  1144.         int size = s.readInt();
  1146.         // Read in all elements in the proper order.
  1147.         for (int i = 0; i < size; i++)
  1148.             linkLast((E)s.readObject());
  1149.     }
  1151.     /**
  1152.      * Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>
  1153.      * and <em>fail-fast</em> {@link Spliterator} over the elements in this
  1154.      * list.
  1155.      *
  1156.      * <p>The {@code Spliterator} reports {@link Spliterator#SIZED} and
  1157.      * {@link Spliterator#ORDERED}.  Overriding implementations should document
  1158.      * the reporting of additional characteristic values.
  1159.      *
  1160.      * @implNote
  1161.      * The {@code Spliterator} additionally reports {@link Spliterator#SUBSIZED}
  1162.      * and implements {@code trySplit} to permit limited parallelism..
  1163.      *
  1164.      * @return a {@code Spliterator} over the elements in this list
  1165.      * @since 1.8
  1166.      */
  1167.     @Override
  1168.     public Spliterator<E> spliterator() {
  1169.         return new LLSpliterator<E>(this, -1, 0);
  1170.     }
  1172.     /** A customized variant of Spliterators.IteratorSpliterator */
  1173.     static final class LLSpliterator<E> implements Spliterator<E> {
  1174.         static final int BATCH_UNIT = 1 << 10;  // batch array size increment
  1175.         static final int MAX_BATCH = 1 << 25;  // max batch array size;
  1176.         final LinkedList<E> list; // null OK unless traversed
  1177.         Node<E> current;      // current node; null until initialized
  1178.         int est;              // size estimate; -1 until first needed
  1179.         int expectedModCount; // initialized when est set
  1180.         int batch;            // batch size for splits
  1182.         LLSpliterator(LinkedList<E> list, int est, int expectedModCount) {
  1183.             this.list = list;
  1184.             this.est = est;
  1185.             this.expectedModCount = expectedModCount;
  1186.         }
  1188.         final int getEst() {
  1189.             int s; // force initialization
  1190.             final LinkedList<E> lst;
  1191.             if ((s = est) < 0) {
  1192.                 if ((lst = list) == null)
  1193.                     s = est = 0;
  1194.                 else {
  1195.                     expectedModCount = lst.modCount;
  1196.                     current = lst.first;
  1197.                     s = est = lst.size;
  1198.                 }
  1199.             }
  1200.             return s;
  1201.         }
  1203.         public long estimateSize() { return (long) getEst(); }
  1205.         public Spliterator<E> trySplit() {
  1206.             Node<E> p;
  1207.             int s = getEst();
  1208.             if (s > 1 && (p = current) != null) {
  1209.                 int n = batch + BATCH_UNIT;
  1210.                 if (n > s)
  1211.                     n = s;
  1212.                 if (n > MAX_BATCH)
  1213.                     n = MAX_BATCH;
  1214.                 Object[] a = new Object[n];
  1215.                 int j = 0;
  1216.                 do { a[j++] = p.item; } while ((p = p.next) != null && j < n);
  1217.                 current = p;
  1218.                 batch = j;
  1219.                 est = s - j;
  1220.                 return Spliterators.spliterator(a, 0, j, Spliterator.ORDERED);
  1221.             }
  1222.             return null;
  1223.         }
  1225.         public void forEachRemaining(Consumer<? super E> action) {
  1226.             Node<E> p; int n;
  1227.             if (action == null) throw new NullPointerException();
  1228.             if ((n = getEst()) > 0 && (p = current) != null) {
  1229.                 current = null;
  1230.                 est = 0;
  1231.                 do {
  1232.                     E e = p.item;
  1233.                     p = p.next;
  1234.                     action.accept(e);
  1235.                 } while (p != null && --n > 0);
  1236.             }
  1237.             if (list.modCount != expectedModCount)
  1238.                 throw new ConcurrentModificationException();
  1239.         }
  1241.         public boolean tryAdvance(Consumer<? super E> action) {
  1242.             Node<E> p;
  1243.             if (action == null) throw new NullPointerException();
  1244.             if (getEst() > 0 && (p = current) != null) {
  1245.                 --est;
  1246.                 E e = p.item;
  1247.                 current = p.next;
  1248.                 action.accept(e);
  1249.                 if (list.modCount != expectedModCount)
  1250.                     throw new ConcurrentModificationException();
  1251.                 return true;
  1252.             }
  1253.             return false;
  1254.         }
  1256.         public int characteristics() {
  1257.             return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
  1258.         }
  1259.     }
  1261. }

参考

原文链接:https://www.cnblogs.com/liuyun1995/p/8287707.html

Java集合基于JDK1.8的LinkedList源码分析的更多相关文章

  1. Java集合基于JDK1.8的ArrayList源码分析

    本篇分析ArrayList的源码,在分析之前先跟大家谈一谈数组.数组可能是我们最早接触到的数据结构之一,它是在内存中划分出一块连续的地址空间用来进行元素的存储,由于它直接操作内存,所以数组的性能要比集 ...

  2. Java -- 基于JDK1.8的LinkedList源码分析

    1,上周末我们一起分析了ArrayList的源码并进行了一些总结,因为最近在看Collection这一块的东西,下面的图也是大致的总结了Collection里面重要的接口和类,如果没有意外的话后面基本 ...

  3. 基于JDK1.8的LinkedList源码学习笔记

    LinkedList作为一种常用的List,是除了ArrayList之外最有用的List.其同样实现了List接口,但是除此之外它同样实现了Deque接口,而Deque是一个双端队列接口,其继承自Qu ...

  4. Java集合框架之二：LinkedList源码解析

    版权声明:本文为博主原创文章,转载请注明出处,欢迎交流学习! LinkedList底层是通过双向循环链表来实现的,其结构如下图所示: 链表的组成元素我们称之为节点,节点由三部分组成:前一个节点的引用地 ...

  5. Java -- 基于JDK1.8的ArrayList源码分析

    1,前言 很久没有写博客了,很想念大家,18年都快过完了,才开始写第一篇,争取后面每周写点,权当是记录,因为最近在看JDK的Collection,而且ArrayList源码这一块也经常被面试官问道,所 ...

  6. Java 集合系列（四）—— ListIterator 源码分析

    以脑图的形式来展示Java集合知识,让零碎知识点形成体系 Iterator 对比   Iterator(迭代器)是一种设计模式,是一个对象,用于遍历集合中的所有元素.  Iterator 包含四个方法 ...

  7. 7.Java集合-Arrays类实现原理及源码分析

    Java集合---Arrays类源码解析  转自:http://www.cnblogs.com/ITtangtang/p/3948765.html 一.Arrays.sort()数组排序 Java A ...

  8. Java -- 基于JDK1.8的ThreadLocal源码分析

    1,最近在做一个需求的时候需要对外部暴露一个值得应用  ,一般来说直接写个单例,将这个成员变量的值暴露出去就ok了,但是当时突然灵机一动(现在回想是个多余的想法),想到handle源码里面有使用过Th ...

  9. java集合框架02——Collection架构与源码分析

    Collection是一个接口,它主要的两个分支是List和Set.如下图所示: List和Set都是接口,它们继承与Collection.List是有序的队列,可以用重复的元素:而Set是数学概念中 ...

随机推荐

  1. ERROR: but there is no YARN_RESOURCEMANAGER_USER defined. Aborting operation.

    将start-dfs.sh,stop-dfs.sh两个文件顶部添加以下参数 HDFS_NAMENODE_USER=root HDFS_DATANODE_USER=root HDFS_SECONDARY ...

  2. pta 7-1 找出不是两个数组共有的元素

    给定两个整型数组,本题要求找出不是两者共有的元素. 输入格式: 输入分别在两行中给出两个整型数组,每行先给出正整数N(≤20),随后是N个整数,其间以空格分隔. 输出格式: 在一行中按照数字给出的顺序 ...

  3. mysql 连接数据库时时区报错

    1.url: jdbc:mysql://192.168.0.101:3306/testdb?serverTimezone=UTC,在连接字符后面添加时区设置 2.使用navicat或者直接使用mysq ...

  4. mysql8 Could not retrieve transation read-only status server

    想回顾下ssm,看着网上别的帖子手动搭了一个,一直报Could not retrieve transation read-only status server , java.sql.SQLExcept ...

  5. 刷题56. Merge Intervals

    一.题目说明 题目是56. Merge Intervals,给定一列区间的集合,归并重叠区域. 二.我的做法 这个题目不难,先对intervals排序,然后取下一个集合,如果cur[0]>res ...

  6. 122、Java面向对象之直接输出对象本身

    01.代码如下: package TIANPAN; class Book { public void print() { // 调用print()方法的对象就是当前对象,this就自动与此对象指向同一 ...

  7. 《编写高质量iOS与OS X代码的52个有效方法》书籍目录

    一.熟悉Objective-C 1.了解Objective-C语言的起源 2.在类的头文件中尽量少引入其他头文件 3.多用字面量语法,少用与之等价的方法 4.多用类型常量,少用#define预处理指令 ...

  8. Oracle如何修改密码？如何解锁scott用户？

    修改密码: scott用户的密码不对,进入管理员用户,修改scott用户密码即可 或者这样修改密码:在运行栏里面敲:sqlplus(空格)/nolog 回车接着在弹出框里面敲:conn sys/pas ...

  9. 【mysql】mysq8.0新特性

    一.MySQL8.0简介   mysql8.0现在已经发布,2016-09-12第一个DM(development milestone)版本8.0.0发布.新的版本带来很多新功能和新特性,对性能也得到 ...

  10. Mybatis-问题总结

    1.在mybatis里面注释语句的时候,一定用 <!- -需要注释的内容–>.用快捷键注释一行代码显示是/**/,但是实际执行起来报错.