LinkedList类源码学习
源码版本：Java8
/** Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.*********************/package source;import java.util.*;
import java.util.function.Consumer;/*** Doubly-linked list implementation of the {@code List} and {@code Deque}* interfaces. Implements all optional list operations, and permits all* elements (including {@code null}).** <p>All of the operations perform as could be expected for a doubly-linked* list. Operations that index into the list will traverse the list from* the beginning or the end, whichever is closer to the specified index.** <p><strong>Note that this implementation is not synchronized.</strong>* If multiple threads access a linked list concurrently, and at least* one of the threads modifies the list structurally, it <i>must</i> be* synchronized externally. (A structural modification is any operation* that adds or deletes one or more elements; merely setting the value of* an element is not a structural modification.) This is typically* accomplished by synchronizing on some object that naturally* encapsulates the list.** If no such object exists, the list should be "wrapped" using the* {@link Collections#synchronizedList Collections.synchronizedList}* method. This is best done at creation time, to prevent accidental* unsynchronized access to the list:<pre>* List list = Collections.synchronizedList(new LinkedList(...));</pre>** <p>The iterators returned by this class's {@code iterator} and* {@code listIterator} methods are <i>fail-fast</i>: if the list is* structurally modified at any time after the iterator is created, in* any way except through the Iterator's own {@code remove} or* {@code add} methods, the iterator will throw a {@link* ConcurrentModificationException}. Thus, in the face of concurrent* modification, the iterator fails quickly and cleanly, rather than* risking arbitrary, non-deterministic behavior at an undetermined* time in the future.** <p>Note that the fail-fast behavior of an iterator cannot be guaranteed* as it is, generally speaking, impossible to make any hard guarantees in the* presence of unsynchronized concurrent modification. Fail-fast iterators* throw {@code ConcurrentModificationException} on a best-effort basis.* Therefore, it would be wrong to write a program that depended on this* exception for its correctness: <i>the fail-fast behavior of iterators* should be used only to detect bugs.</i>** <p>This class is a member of the* <a href="{@docRoot}/../technotes/guides/collections/index.html">* Java Collections Framework</a>.** @author Josh Bloch* @see List* @see ArrayList* @since 1.2* @param <E> the type of elements held in this collection*/public class LinkedList<E>extends AbstractSequentialList<E>implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{//链表长度transient int size = 0;/*** Pointer to first node.* Invariant: (first == null && last == null) ||* (first.prev == null && first.item != null)*///头结点transient Node<E> first;/*** Pointer to last node.* Invariant: (first == null && last == null) ||* (last.next == null && last.item != null)*///尾结点transient Node<E> last;/*** 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);}/*** Links e as first element.*///将值为e的结点作为第一个结点private void linkFirst(E e) {//用f记录旧的第一个结点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++;}/*** Links e as last element.*///将值为e的结点作为最后一个结点void linkLast(E e) {//用l记录旧的最后一个结点final Node<E> l = last;final Node<E> newNode = new Node<>(l, e, null);//更新最后一个结点last = newNode;if (l == null)//适用之前链表为空的情况，现在最后一个结点也是第一个结点first = newNode;else//将新的最后一个结点连到旧的最后一个结点后面l.next = newNode;//更新链表长度size++;//更新修改次数modCount++;}/*** Inserts element e before non-null Node succ.*///插入到指定结点之前void linkBefore(E e, Node<E> succ) {// assert succ != null;final Node<E> pred = succ.prev;final Node<E> newNode = new Node<>(pred, e, succ);succ.prev = newNode;if (pred == null)//指定结点为第二个结点的情况first = newNode;elsepred.next = newNode;//更新链表长度size++;//更新修改次数modCount++;}/*** Unlinks non-null first node f.*///切断第一个结点与链表的连接private E unlinkFirst(Node<E> f) {// assert f == first && f != null;final E element = f.item;final Node<E> next = f.next;f.item = null;f.next = null; // help GC//更新第一个结点first = next;if (next == null)//断开前链表只有一个结点的情况last = null;elsenext.prev = null;//更新链表长度size--;//更新修改次数modCount++;//返回断连结点的值return element;}/*** Unlinks non-null last node l.*///切断最后一个结点与链表的连接private E unlinkLast(Node<E> l) {// assert l == last && l != null;final E element = l.item;final Node<E> prev = l.prev;l.item = null;l.prev = null; // help GC//更新最后一个结点last = prev;if (prev == null)//断开前链表只有一个结点的情况first = null;elseprev.next = null;//更新链表长度size--;//更新修改次数modCount++;//返回断连结点的值return element;}/*** Unlinks non-null node x.*///切断指定结点与链表的连接E unlink(Node<E> x) {// assert x != null;final E element = x.item;final Node<E> next = x.next;final Node<E> prev = x.prev;if (prev == null) {//指定的结点为第一个结点first = next;} else {prev.next = next;x.prev = null;}if (next == null) {//指定的结点为最后一个结点last = prev;} else {next.prev = prev;x.next = null;}x.item = null;//更新链表长度size--;//更新修改次数modCount++;//返回断连结点的值return element;}/*** Returns the first element in this list.** @return the first element in this list* @throws NoSuchElementException if this list is empty*///获取第一个结点的值public E getFirst() {final Node<E> f = first;if (f == null)throw new NoSuchElementException();return f.item;}/*** Returns the last element in this list.** @return the last element in this list* @throws NoSuchElementException if this list is empty*///获取最后一个结点的值public E getLast() {final Node<E> l = last;if (l == null)throw new NoSuchElementException();return l.item;}/*** Removes and returns the first element from this list.** @return the first element from this list* @throws NoSuchElementException if this list is empty*///切断第一个结点与链表的连接public E removeFirst() {final Node<E> f = first;if (f == null)throw new NoSuchElementException();return unlinkFirst(f);}/*** Removes and returns the last element from this list.** @return the last element from this list* @throws NoSuchElementException if this list is empty*///切断最后一个结点与链表的连接public E removeLast() {final Node<E> l = last;if (l == null)throw new NoSuchElementException();return unlinkLast(l);}/*** Inserts the specified element at the beginning of this list.** @param e the element to add*///将值为e的结点作为第一个结点public void addFirst(E e) {linkFirst(e);}/*** Appends the specified element to the end of this list.** <p>This method is equivalent to {@link #add}.** @param e the element to add*///将值为e的结点作为最后一个结点public void addLast(E e) {linkLast(e);}/*** Returns {@code true} if this list contains the specified element.* More formally, returns {@code true} if and only if this list contains* at least one element {@code e} such that* <tt>(o==null ? e==null : o.equals(e))</tt>.** @param o element whose presence in this list is to be tested* @return {@code true} if this list contains the specified element*///判断链表中是否包含指定元素public boolean contains(Object o) {return indexOf(o) != -1;}/*** Returns the number of elements in this list.** @return the number of elements in this list*///返回链表长度public int size() {return size;}/*** Appends the specified element to the end of this list.** <p>This method is equivalent to {@link #addLast}.** @param e element to be appended to this list* @return {@code true} (as specified by {@link Collection#add})*///将值为e的结点作为最后一个结点public boolean add(E e) {linkLast(e);return true;}/*** Removes the first occurrence of the specified element from this list,* if it is present. If this list does not contain the element, it is* unchanged. More formally, removes the element with the lowest index* {@code i} such that* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>* (if such an element exists). Returns {@code true} if this list* contained the specified element (or equivalently, if this list* changed as a result of the call).** @param o element to be removed from this list, if present* @return {@code true} if this list contained the specified element*///移除第一次出现的值为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);return true;}}} else {for (Node<E> x = first; x != null; x = x.next) {if (o.equals(x.item)) {unlink(x);return true;}}}return false;}/*** Appends all of the elements in the specified collection to the end of* this list, in the order that they are returned by the specified* collection's iterator. The behavior of this operation is undefined if* the specified collection is modified while the operation is in* progress. (Note that this will occur if the specified collection is* this list, and it's nonempty.)** @param c collection containing elements to be added to this list* @return {@code true} if this list changed as a result of the call* @throws NullPointerException if the specified collection is null*///批量添加元素，默认开始位置为链表末尾//注意：如果该方法用于初始化空的链表则在0处开始，即把集合中的元素全部赋给空链表// 如果链表非空，则将集合中的元素追加到链表中public boolean addAll(Collection<? extends E> c) {return addAll(size, c);}/*** Inserts all of the elements in the specified collection into this* list, starting at the specified position. Shifts the element* currently at that position (if any) and any subsequent elements to* the right (increases their indices). The new elements will appear* in the list in the order that they are returned by the* specified collection's iterator.** @param index index at which to insert the first element* from the specified collection* @param c collection containing elements to be added to this list* @return {@code true} if this list changed as a result of the call* @throws IndexOutOfBoundsException {@inheritDoc}* @throws NullPointerException if the specified collection is null*///指定添加元素的起始位置，批量添加元素//经实践发现是在某位置之前塞入集合中的元素public boolean addAll(int index, Collection<? extends E> c) {//检查起始位置是否合法checkPositionIndex(index);//将集合转化为数组，并使用一个对象数组用于接收转化后数组Object[] a = c.toArray();//获取对象数组长度int numNew = a.length;//没有元素直接返回错误if (numNew == 0)return false;//分别创建前驱和后继结点//succeed 后继Node<E> pred, succ;if (index == size) {//用于初始化空链表（0==0），或者人为指定在非空链表最后位置追加succ = null;pred = last;} else {//指定了添加的起始位置不在最后succ = node(index);pred = succ.prev;}//将数组中的单个元素转结点然后串起来for (Object o : a) {@SuppressWarnings("unchecked") E e = (E) o;Node<E> newNode = new Node<>(pred, e, null);//作为第一个结点if (pred == null)first = newNode;elsepred.next = newNode;pred = newNode;}if (succ == null) {//遍历结束后指向最后一个结点last = pred;} else {//将塞入的元素串缝合到原链表pred.next = succ;succ.prev = pred;}//更新长度size += numNew;//增加修改次数modCount++;return true;}/*** Removes all of the elements from this list.* The list will be empty after this call returns.*///清空链表public void clear() {// Clearing all of the links between nodes is "unnecessary", but:// - helps a generational GC if the discarded nodes inhabit// more than one generation// - is sure to free memory even if there is a reachable Iteratorfor (Node<E> x = first; x != null; ) {Node<E> next = x.next;x.item = null;x.next = null;x.prev = null;x = next;}first = last = null;size = 0;modCount++;}// Positional Access Operations/*** Returns the element at the specified position in this list.** @param index index of the element to return* @return the element at the specified position in this list* @throws IndexOutOfBoundsException {@inheritDoc}*///获取指定下标结点值public E get(int index) {//检查下标是否合法checkElementIndex(index);return node(index).item;}/*** Replaces the element at the specified position in this list with the* specified element.** @param index index of the element to replace* @param element element to be stored at the specified position* @return the element previously at the specified position* @throws IndexOutOfBoundsException {@inheritDoc}*///设置指定下标结点的值并返回更新前的值public E set(int index, E element) {//检查下标是否合法checkElementIndex(index);//获取到下标结点Node<E> x = node(index);//获取旧值E oldVal = x.item;//新值覆盖旧值x.item = element;//返回旧值return oldVal;}/*** Inserts the specified element at the specified position in this list.* Shifts the element currently at that position (if any) and any* subsequent elements to the right (adds one to their indices).** @param index index at which the specified element is to be inserted* @param element element to be inserted* @throws IndexOutOfBoundsException {@inheritDoc}*///在指定下标之前添加结点public void add(int index, E element) {//检查下标是否合法checkPositionIndex(index);if (index == size)//添加到链表末尾linkLast(element);else//添加到指定位置linkBefore(element, node(index));}/*** Removes the element at the specified position in this list. Shifts any* subsequent elements to the left (subtracts one from their indices).* Returns the element that was removed from the list.** @param index the index of the element to be removed* @return the element previously at the specified position* @throws IndexOutOfBoundsException {@inheritDoc}*///断开指定下标结点与链表的连接public E remove(int index) {//检查下标是否合法checkElementIndex(index);return unlink(node(index));}/*** Tells if the argument is the index of an existing element.*///检查下标是否合法private boolean isElementIndex(int index) {return index >= 0 && index < size;}/*** Tells if the argument is the index of a valid position for an* iterator or an add operation.*///判断实参是否为迭代器或添加操作的有效位置的下标。private boolean isPositionIndex(int index) {return index >= 0 && index <= size;}/*** Constructs an IndexOutOfBoundsException detail message.* Of the many possible refactorings of the error handling code,* this "outlining" performs best with both server and client VMs.*/private String outOfBoundsMsg(int index) {return "Index: "+index+", Size: "+size;}//检查下标是否合法private void checkElementIndex(int index) {if (!isElementIndex(index))throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}//检查下标位置，不合法就抛出下标越界异常private void checkPositionIndex(int index) {if (!isPositionIndex(index))throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}/*** Returns the (non-null) Node at the specified element index.*///返回指定元素索引处的(非空)节点。Node<E> node(int index) {// assert isElementIndex(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;}}// Search Operations/*** Returns the index of the first occurrence of the specified element* in this list, or -1 if this list does not contain the element.* More formally, returns the lowest index {@code i} such that* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,* or -1 if there is no such index.** @param o element to search for* @return the index of the first occurrence of the specified element in* this list, or -1 if this list does not contain the element*///返回指定元素索引处的(非空)节点。指定元素在列表中第一次出现的索引，如果列表中不包含该元素，则为-1public int indexOf(Object o) {int index = 0;if (o == null) {//传入对象为空，返回链表长度for (Node<E> x = first; x != null; x = x.next) {if (x.item == null)return index;index++;}} else {//找到后返回下标位置for (Node<E> x = first; x != null; x = x.next) {if (o.equals(x.item))return index;index++;}}//未找到则返回-1return -1;}/*** Returns the index of the last occurrence of the specified element* in this list, or -1 if this list does not contain the element.* More formally, returns the highest index {@code i} such that* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,* or -1 if there is no such index.** @param o element to search for* @return the index of the last occurrence of the specified element in* this list, or -1 if this list does not contain the element*///返回指定元素索引处的(非空)节点。指定元素在列表中最后一次出现的索引，如果列表中不包含该元素，则为-1public int lastIndexOf(Object o) {int index = size;if (o == null) {for (Node<E> x = last; x != null; x = x.prev) {index--;if (x.item == null)return index;}} else {for (Node<E> x = last; x != null; x = x.prev) {index--;if (o.equals(x.item))return index;}}return -1;}// Queue operations./*** Retrieves, but does not remove, the head (first element) of this list.** @return the head of this list, or {@code null} if this list is empty* @since 1.5*///查看第一个结点的值public E peek() {final Node<E> f = first;return (f == null) ? null : f.item;}/*** Retrieves, but does not remove, the head (first element) of this list.** @return the head of this list* @throws NoSuchElementException if this list is empty* @since 1.5*///获取第一个结点的值public E element() {return getFirst();}/*** Retrieves and removes the head (first element) of this list.** @return the head of this list, or {@code null} if this list is empty* @since 1.5*///切断第一个结点与链表的连接public E poll() {final Node<E> f = first;return (f == null) ? null : unlinkFirst(f);}/*** Retrieves and removes the head (first element) of this list.** @return the head of this list* @throws NoSuchElementException if this list is empty* @since 1.5*///切断第一个结点与链表的连接public E remove() {return removeFirst();}/*** Adds the specified element as the tail (last element) of this list.** @param e the element to add* @return {@code true} (as specified by {@link Queue#offer})* @since 1.5*///将值为e的结点作为最后一个结点public boolean offer(E e) {return add(e);}// Deque operations/*** Inserts the specified element at the front of this list.** @param e the element to insert* @return {@code true} (as specified by {@link Deque#offerFirst})* @since 1.6*///将值为e的结点作为第一个结点public boolean offerFirst(E e) {addFirst(e);return true;}/*** Inserts the specified element at the end of this list.** @param e the element to insert* @return {@code true} (as specified by {@link Deque#offerLast})* @since 1.6*///将值为e的结点作为最后一个结点public boolean offerLast(E e) {addLast(e);return true;}/*** Retrieves, but does not remove, the first element of this list,* or returns {@code null} if this list is empty.** @return the first element of this list, or {@code null}* if this list is empty* @since 1.6*///查看第一个结点的值public E peekFirst() {final Node<E> f = first;return (f == null) ? null : f.item;}/*** Retrieves, but does not remove, the last element of this list,* or returns {@code null} if this list is empty.** @return the last element of this list, or {@code null}* if this list is empty* @since 1.6*///查看最后一个结点的值public E peekLast() {final Node<E> l = last;return (l == null) ? null : l.item;}/*** Retrieves and removes the first element of this list,* or returns {@code null} if this list is empty.** @return the first element of this list, or {@code null} if* this list is empty* @since 1.6*///切断第一个结点与链表的连接public E pollFirst() {final Node<E> f = first;return (f == null) ? null : unlinkFirst(f);}/*** Retrieves and removes the last element of this list,* or returns {@code null} if this list is empty.** @return the last element of this list, or {@code null} if* this list is empty* @since 1.6*///切断最后一个结点与链表的连接public E pollLast() {final Node<E> l = last;return (l == null) ? null : unlinkLast(l);}/*** Pushes an element onto the stack represented by this list. In other* words, inserts the element at the front of this list.** <p>This method is equivalent to {@link #addFirst}.** @param e the element to push* @since 1.6*///将值为e的结点作为第一个结点public void push(E e) {addFirst(e);}/*** Pops an element from the stack represented by this list. In other* words, removes and returns the first element of this list.** <p>This method is equivalent to {@link #removeFirst()}.** @return the element at the front of this list (which is the top* of the stack represented by this list)* @throws NoSuchElementException if this list is empty* @since 1.6*///切断第一个结点与链表的连接public E pop() {return removeFirst();}/*** Removes the first occurrence of the specified element in this* list (when traversing the list from head to tail). If the list* does not contain the element, it is unchanged.** @param o element to be removed from this list, if present* @return {@code true} if the list contained the specified element* @since 1.6*///移除第一次出现的值为o的结点public boolean removeFirstOccurrence(Object o) {return remove(o);}/*** Removes the last occurrence of the specified element in this* list (when traversing the list from head to tail). If the list* does not contain the element, it is unchanged.** @param o element to be removed from this list, if present* @return {@code true} if the list contained the specified element* @since 1.6*///移除最后一次出现的值为o的结点public boolean removeLastOccurrence(Object o) {if (o == null) {for (Node<E> x = last; x != null; x = x.prev) {if (x.item == null) {unlink(x);return true;}}} else {for (Node<E> x = last; x != null; x = x.prev) {if (o.equals(x.item)) {unlink(x);return true;}}}return false;}/*** Returns a list-iterator of the elements in this list (in proper* sequence), starting at the specified position in the list.* Obeys the general contract of {@code List.listIterator(int)}.<p>** The list-iterator is <i>fail-fast</i>: if the list is structurally* modified at any time after the Iterator is created, in any way except* through the list-iterator's own {@code remove} or {@code add}* methods, the list-iterator will throw a* {@code ConcurrentModificationException}. Thus, in the face of* concurrent modification, the iterator fails quickly and cleanly, rather* than risking arbitrary, non-deterministic behavior at an undetermined* time in the future.** @param index index of the first element to be returned from the* list-iterator (by a call to {@code next})* @return a ListIterator of the elements in this list (in proper* sequence), starting at the specified position in the list* @throws IndexOutOfBoundsException {@inheritDoc}* @see List#listIterator(int)*/public ListIterator<E> listIterator(int index) {checkPositionIndex(index);return new ListItr(index);}//线性表迭代器类private class ListItr implements ListIterator<E> {//记录上一次返回的结点private Node<E> lastReturned;//记录当前结点private Node<E> next;//记录当前结点的下标private int nextIndex;private int expectedModCount = modCount;ListItr(int index) {// assert isPositionIndex(index);next = (index == size) ? null : node(index);nextIndex = index;}//判断是否存在后继结点public boolean hasNext() {return nextIndex < size;}//移动到后继结点，再返回上一个结点的值public E next() {checkForComodification();if (!hasNext())throw new NoSuchElementException();lastReturned = next;next = next.next;nextIndex++;return lastReturned.item;}//判断是否存在前驱结点public boolean hasPrevious() {return nextIndex > 0;}//移动到前驱结点，再返回上一个结点的值public E previous() {checkForComodification();if (!hasPrevious())throw new NoSuchElementException();lastReturned = next = (next == null) ? last : next.prev;nextIndex--;return lastReturned.item;}//返回当前结点的下标public int nextIndex() {return nextIndex;}//返回前驱结点的下标public int previousIndex() {return nextIndex - 1;}//断开上一次返回结点与链表的连接public void remove() {checkForComodification();if (lastReturned == null)throw new IllegalStateException();Node<E> lastNext = lastReturned.next;unlink(lastReturned);if (next == lastReturned)next = lastNext;elsenextIndex--;lastReturned = null;expectedModCount++;}//设置上一次返回结点的值为epublic void set(E e) {if (lastReturned == null)throw new IllegalStateException();checkForComodification();lastReturned.item = e;}//插入到指定结点之前public void add(E e) {checkForComodification();lastReturned = null;if (next == null)linkLast(e);elselinkBefore(e, next);nextIndex++;expectedModCount++;}public void forEachRemaining(Consumer<? super E> action) {Objects.requireNonNull(action);while (modCount == expectedModCount && nextIndex < size) {action.accept(next.item);lastReturned = next;next = next.next;nextIndex++;}checkForComodification();}final void checkForComodification() {if (modCount != expectedModCount)throw new ConcurrentModificationException();}}//结点类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;}}/*** @since 1.6*/public Iterator<E> descendingIterator() {return new DescendingIterator();}/*** Adapter to provide descending iterators via ListItr.previous*/private class DescendingIterator implements Iterator<E> {private final ListItr itr = new ListItr(size());public boolean hasNext() {return itr.hasPrevious();}public E next() {return itr.previous();}public void remove() {itr.remove();}}@SuppressWarnings("unchecked")private LinkedList<E> superClone() {try {return (LinkedList<E>) super.clone();} catch (CloneNotSupportedException e) {throw new InternalError(e);}}/*** Returns a shallow copy of this {@code LinkedList}. (The elements* themselves are not cloned.)** @return a shallow copy of this {@code LinkedList} instance*/public Object clone() {LinkedList<E> clone = superClone();// Put clone into "virgin" stateclone.first = clone.last = null;clone.size = 0;clone.modCount = 0;// Initialize clone with our elementsfor (Node<E> x = first; x != null; x = x.next)clone.add(x.item);return clone;}/*** Returns an array containing all of the elements in this list* in proper sequence (from first to last element).** <p>The returned array will be "safe" in that no references to it are* maintained by this list. (In other words, this method must allocate* a new array). The caller is thus free to modify the returned array.** <p>This method acts as bridge between array-based and collection-based* APIs.** @return an array containing all of the elements in this list* in proper sequence*/public Object[] toArray() {Object[] result = new Object[size];int i = 0;for (Node<E> x = first; x != null; x = x.next)result[i++] = x.item;return result;}/*** Returns an array containing all of the elements in this list in* proper sequence (from first to last element); the runtime type of* the returned array is that of the specified array. If the list fits* in the specified array, it is returned therein. Otherwise, a new* array is allocated with the runtime type of the specified array and* the size of this list.** <p>If the list fits in the specified array with room to spare (i.e.,* the array has more elements than the list), the element in the array* immediately following the end of the list is set to {@code null}.* (This is useful in determining the length of the list <i>only</i> if* the caller knows that the list does not contain any null elements.)** <p>Like the {@link #toArray()} method, this method acts as bridge between* array-based and collection-based APIs. Further, this method allows* precise control over the runtime type of the output array, and may,* under certain circumstances, be used to save allocation costs.** <p>Suppose {@code x} is a list known to contain only strings.* The following code can be used to dump the list into a newly* allocated array of {@code String}:** <pre>* String[] y = x.toArray(new String[0]);</pre>** Note that {@code toArray(new Object[0])} is identical in function to* {@code toArray()}.** @param a the array into which the elements of the list are to* be stored, if it is big enough; otherwise, a new array of the* same runtime type is allocated for this purpose.* @return an array containing the elements of the list* @throws ArrayStoreException if the runtime type of the specified array* is not a supertype of the runtime type of every element in* this list* @throws NullPointerException if the specified array is null*/@SuppressWarnings("unchecked")public <T> T[] toArray(T[] a) {if (a.length < size)a = (T[])java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size);int i = 0;Object[] result = a;for (Node<E> x = first; x != null; x = x.next)result[i++] = x.item;if (a.length > size)a[size] = null;return a;}private static final long serialVersionUID = 876323262645176354L;/*** Saves the state of this {@code LinkedList} instance to a stream* (that is, serializes it).** @serialData The size of the list (the number of elements it* contains) is emitted (int), followed by all of its* elements (each an Object) in the proper order.*/private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException {// Write out any hidden serialization magics.defaultWriteObject();// Write out sizes.writeInt(size);// Write out all elements in the proper order.for (Node<E> x = first; x != null; x = x.next)s.writeObject(x.item);}/*** Reconstitutes this {@code LinkedList} instance from a stream* (that is, deserializes it).*/@SuppressWarnings("unchecked")private void readObject(java.io.ObjectInputStream s)throws java.io.IOException, ClassNotFoundException {// Read in any hidden serialization magics.defaultReadObject();// Read in sizeint size = s.readInt();// Read in all elements in the proper order.for (int i = 0; i < size; i++)linkLast((E)s.readObject());}/*** Creates a <em><a href="Spliterator.html#binding">late-binding</a></em>* and <em>fail-fast</em> {@link Spliterator} over the elements in this* list.** <p>The {@code Spliterator} reports {@link Spliterator#SIZED} and* {@link Spliterator#ORDERED}. Overriding implementations should document* the reporting of additional characteristic values.** @implNote* The {@code Spliterator} additionally reports {@link Spliterator#SUBSIZED}* and implements {@code trySplit} to permit limited parallelism..** @return a {@code Spliterator} over the elements in this list* @since 1.8*/@Overridepublic Spliterator<E> spliterator() {return new LLSpliterator<E>(this, -1, 0);}/** A customized variant of Spliterators.IteratorSpliterator */static final class LLSpliterator<E> implements Spliterator<E> {static final int BATCH_UNIT = 1 << 10; // batch array size incrementstatic final int MAX_BATCH = 1 << 25; // max batch array size;final LinkedList<E> list; // null OK unless traversedNode<E> current; // current node; null until initializedint est; // size estimate; -1 until first neededint expectedModCount; // initialized when est setint batch; // batch size for splitsLLSpliterator(LinkedList<E> list, int est, int expectedModCount) {this.list = list;this.est = est;this.expectedModCount = expectedModCount;}final int getEst() {int s; // force initializationfinal LinkedList<E> lst;if ((s = est) < 0) {if ((lst = list) == null)s = est = 0;else {expectedModCount = lst.modCount;current = lst.first;s = est = lst.size;}}return s;}public long estimateSize() { return (long) getEst(); }public Spliterator<E> trySplit() {Node<E> p;int s = getEst();if (s > 1 && (p = current) != null) {int n = batch + BATCH_UNIT;if (n > s)n = s;if (n > MAX_BATCH)n = MAX_BATCH;Object[] a = new Object[n];int j = 0;do { a[j++] = p.item; } while ((p = p.next) != null && j < n);current = p;batch = j;est = s - j;return Spliterators.spliterator(a, 0, j, Spliterator.ORDERED);}return null;}public void forEachRemaining(Consumer<? super E> action) {Node<E> p; int n;if (action == null) throw new NullPointerException();if ((n = getEst()) > 0 && (p = current) != null) {current = null;est = 0;do {E e = p.item;p = p.next;action.accept(e);} while (p != null && --n > 0);}if (list.modCount != expectedModCount)throw new ConcurrentModificationException();}public boolean tryAdvance(Consumer<? super E> action) {Node<E> p;if (action == null) throw new NullPointerException();if (getEst() > 0 && (p = current) != null) {--est;E e = p.item;current = p.next;action.accept(e);if (list.modCount != expectedModCount)throw new ConcurrentModificationException();return true;}return false;}public int characteristics() {return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;}}}
发布评论