LinkedList源码分析
LinkedList源码分析
1.须知
怎样阅读源码
版本改动
LinkedList的结构
transient关键字的作用
2.一些常用的操作
添加元素add(E e)
在指定节点前插入元素linkBefore(E e, Node succ)
添加元素作为首节点linkFirst(E e)
删除首节点并返回首节点的值private E unlinkFirst(Node f)
3.对整个源码分析
1.须知
怎样阅读源码
版本改动
LinkedList的结构
transient关键字的作用
2.一些常用的操作
添加元素add(E e)
在指定节点前插入元素linkBefore(E e, Node succ)
添加元素作为首节点linkFirst(E e)
删除首节点并返回首节点的值private E unlinkFirst(Node f)
3.对整个源码分析
1.须知
怎样阅读源码
打开eclipse或IDEA，这里我使用的是IDEA,ctrl+N查找LinkedList，接着新建一个LinkedList的类，将查到的LinkedList源码全部复制到你建的类中，解决错误,接着就可以一行行阅读了。
版本改动
本次源码使用的jdk1.8源码和1.6之前(包含1.6)的源码不同，1.7以后oracle将LinkedList做了一些优化，将1.6中的环形结构优化为直线型链表结构。
LinkedList的结构
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable- LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
- LinkedList 实现 List 接口，能对它进行队列操作。
- LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
- LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
- LinkedList 实现java.io.Serializable接口，这意味着
- LinkedList支持序列化，能通过序列化去传输。
- LinkedList 是非同步的。
transient关键字的作用
一个对象只要实现了Serilizable接口，这个对象就可以被序列化,java的这种序列化模式为开发者提供了很多便利，可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个的所有属性和方法都会自动序列化。但是有种情况是有些属性是不需要序列号的，所以就用到这个关键字。只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient, 序列化对象的时候，这个属性就不会序列化到指定的目的地中。
2.一些常用的操作
添加元素add(E e)
在指定节点前插入元素linkBefore(E e, Node
添加元素作为首节点linkFirst(E e)
删除首节点并返回首节点的值private E unlinkFirst(Node
3.对整个源码分析
有点长，不过分析比较容易.
package list;
import java.util.*;
import java.util.function.Consumer;
/**
* LinkedList底层使用双向链表，实现了List和deque。实现所有的可选List操作，并可以只有所有元素（包括空值）
* 其大小理论上仅受内存大小的限制
*
*注意：1.7 之后,oracle将LinkedList做了一些优化，将1.6中的环形结构优化为直线型链表结构。
*
* 把对链表的操作封装起来，并对外提供看起来是对普通列表操作的方法。
* 遍历从起点、终点、或指定位置开始
* 内部方法，注释会描述为节点的操作(如删除第一个节点)，公开的方法会描述为元素的操作(如删除第一个元素)
*
* LinkedList不是线程安全的，如果在多线程中使用（修改），需要在外部作同步处理。
*
* 需要弄清元素（节点）的索引和位置的区别，不然有几个地方不好理解，具体在碰到的地方会解释。
*
* 迭代器可以快速报错
*/
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
//元素的实际个数
transient int size = 0;
//首节点
transient Node<E> first;
//尾节点
transient Node<E> last;
//空参构造方法
public LinkedList() {
}
//通过一个集合初始化LinkedList，元素顺序有这个集合的迭代器返回顺序决定
public LinkedList(Collection<? extends E> c) {
this();//调用无参构造函数
addAll(c);//添加集合中的所有元素
}
//添加元素作为第一个节点，内部使用
private void linkFirst(E e) {
final Node<E> f = first;
//创建一个节点，前驱为null，后继为first[-->]
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;//修改first节点的指向
//判断首节点是不是空节点
if (f == null)
//如果首节点是空节点，修改last节点
last = newNode;
else
//如果首节点不是空的，将以前首节点前驱指向新节点[<--]
f.prev = newNode;
size++;
modCount++;
}
//使用对应参数作为尾节点
void linkLast(E e) {
//将新加节点的前驱指向last节点(<--)
final Node<E> l = last;
//创建节点(前驱是last节点，元素为e，后继为null节点)
final Node<E> newNode = new Node<>(l, e, null);
//将last节点修改为指向新节点
last = newNode;
//判断新节点的前节点(就是以前的last节点)是不是为空
if (l == null)
//如果新节点的前节点为空，
// 说明这个list集合是一个空集合，这个新加节点是添加的第一个节点，
//将first节点修改为指向新节点
first = newNode;
else
//如果新节点的前节点不为空
//说明这个list集合有元素
//将前节点的后继修改为新节点(-->)
l.next = newNode;
size++;
modCount++;
}
//在指定节点前插入节点，节点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节点
first = newNode;//将first节点修改为新节点
else
//将指定节点的前节点指向新节点
pred.next = newNode;
size++;
modCount++;
}
//删除首节点并返回删除前首节点的值，首节点不为空,内部使用
private E unlinkFirst(Node<E> f) {
// 断言 f == first && f != null;
final E element = f.item;//取出首节点元素
final Node<E> next = f.next;//得到下一个节点
f.item = null;//将首节点元素置空
f.next = null; // 将节点后继置空，帮助回收
first = next;//首节点的下一个节点成为新的首节点
if (next == null)
//这判断，如果链表中就有一个节点，首节点和尾节点都指向这个节点的话
//首节点的下一个节点为空
last = null; //如果不存在下一个节点，则首尾都为null(空表)
else
next.prev = null;//如果存在下一个节点，那它向前指向null
size--;
modCount++;
return element;
}
//删除尾节点并返回删除前尾节点的值，为节点不为空，内部使用
private E unlinkLast(Node<E> l) {
// 断言 l == last && l != null;
final E element = l.item;//获取值
final Node<E> prev = l.prev;//获取尾节点前一个节点
l.item = null;
l.prev = null; // 便于垃圾回收器清理
last = prev;//前一个节点成为新的尾节点
if (prev == null)
//这说明链表中只有一个节点(first和last都指向它)
first = null;//如果前一个节点不存在，则首尾都为null(空表)
else
prev.next = null;//如果前一个节点存在，先后指向null
size--;
modCount++;
return element;
}
//删除不为空的节点x
E unlink(Node<E> x) {
// 断言 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;
}
//获取第一个元素
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
//获取链表中的最后一个元素
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
/**
* 删除和返回链表中的第一个元素
*/
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
/**
* 删除和返回链表中的最后一个元素
*/
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
/**
* 在list的开始位置插入指定元素
*/
public void addFirst(E e) {
linkFirst(e);
}
//添加元素作为最后一个元素
public void addLast(E e) {
linkLast(e);
}
//检查是否包含某个元素，返回bool
public boolean contains(Object o) {
//返回指定元素的索引位置，不存在就返回-1，然后比较返回bool值
return indexOf(o) != -1;
}
//返回表中元素的数量
public int size() {
return size;
}
/**
* 增加指定元素到list的末尾
*/
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* 删除链表中第一次出现的指定元素，如果这个链表不包括这个元素，不会发生改变
*/
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;
}
//添加指定集合的元素到列表，默认从最后开始添加
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);//list元素索引范围[0,size)
}
/**
* 在list的指定位置开始插入指定集合的所有元素，
* 移动这个位置的元素和后继的所有元素到右边(通过增长他们的索引)
* @param index 指定集合中要插入第一个元素的索引
* @param c 要添加元素到list的集合
* @return {@code true} 如果表发生了改变(集合长度为0时不发生改变)
* @throws IndexOutOfBoundsException {@inheritDoc}
* @throws NullPointerException if the specified collection is null
*/
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);//检查角标是否越界([0,size])
Object[] a = c.toArray(); //得到元素数组
int numNew = a.length;//要添加集合的长度
if (numNew == 0)//若没有元素要添加，直接返回false
return false;
//pred指定位置的前驱节点，succ指定位置的节点
Node<E> pred, succ;
if (index == size) {
//两种情况：1.要添加的list为空，2.添加到list的末尾
//这时:当前节点后一个节点初始化为null，前一个节点为尾节点
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)
//如果list表为空
first = newNode;//若果前节点为null，则新加的节点为首节点
else
//如果存在前节点，前节点会向后指向新加的节点[-->]
pred.next = newNode;
//新加的节点成为前一个节点
pred = newNode;
}
//添加集合中的元素完成后，将指定位置后面的元素后移
if (succ == null) {
//如果list为空或者添加到list的末尾，最后添加的节点成为尾节点
last = pred;
} else {
//添加的位置是list中间，将指定位置和指定位置的元素后移
pred.next = succ;
succ.prev = pred;
}
//修改list大小
size += numNew;
modCount++;
return true;
}
/**
* 移除list表中的所有元素，这个list在这个操作后将会为空
*/
public void clear() {
//方便gc回收垃圾
for (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++;
}
/**
* 返回在链表中指定位置的元素
*/
public E get(int index) {
checkElementIndex(index);//检查角标是否越界[0,size)
return node(index).item;//返回相应位置的元素
}
//修改指定索引的值并返回之前的值
public E set(int index, E element) {
checkElementIndex(index);//检查角标是否越界[0,size)
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
/**
* 在指定的位置插入指定的元素，(插入到指定位置之前)
* 指定位置的元素和任何后继元素都向右移动
*/
public void add(int index, E element) {
checkPositionIndex(index);//检查位置的角标，[0,size]
if (index == size) //如果指定位置为最后，则添加到链表最后
linkLast(element);
else
//如果指定位置不是最后，则添加到指定位置前
linkBefore(element, node(index));
}
/**
* 删除指定位置的元素，
*/
public E remove(int index) {
checkElementIndex(index);//检查元素角标[0,size)
return unlink(node(index));//删除并返回指定位置的旧元素
}
//检查索引是否超出范围，因为元素索引是0--size-1的，所以index必须满足0<=index<size
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
//检查位置是否超出范围，index必须在index--size之间（含），如果超出，返回false
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
/**
* 创建一个IndexOutOfBoundsException的详细消息
*/
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));
}
/**
* 返回指定索引的节点
*/
Node<E> node(int index) {
// 判断位置在链表前半段或者是后半段
if (index < (size >> 1)) {//如果index在链表的前半段
Node<E> x = first;//第一个节点
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {//如果index在链表的后半段
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
//获取指定元素从first开始的索引位置，不存在就返回-1
//不能按条件双向找了，所以通常根据索引获得元素的速度比通过元素获得索引的速度快
public 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++;
}
}
return -1;
}
//获取指定元素从first开始最后出现的索引，不存在就返回-1
//但实际查找是从last开始的
public 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;
}
// 队列的操作
//提供普通队列和双向队列的功能，当然，也可以实现栈，FIFO，FILO
//出队（从前端），获得第一个元素，不存在会返回null，不会删除元素（节点）
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//出队（从前端），不删除元素，若为null会抛出异常而不是返回null
public E element() {
return getFirst();
}
//出队（从前端），如果不存在会返回null，存在的话会返回值并移除这个元素（节点）
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
//出队（从前端），如果不存在会抛出异常而不是返回null，存在的话会返回值并移除这个元素（节点）
public E remove() {
return removeFirst();
}
//入队（从后端），在链表的尾部添加元素，始终返回true
public boolean offer(E e) {
return add(e);
}
// Deque operations
//入队（从前端），在链表的第一个元素前添加元素，始终返回true
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
//入队（从后端），在链表的末尾添加元素，始终返回true
public boolean offerLast(E e) {
addLast(e);
return true;
}
//出队（从前端），获得第一个元素，不存在会返回null，不会删除元素（节点）
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//出队（从后端），获得最后一个元素，不存在会返回null，不会删除元素（节点）
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
//出队（从前端），获得第一个元素，不存在会返回null，会删除元素（节点）
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
//出队（从后端），获得最后一个元素，不存在会返回null，会删除元素（节点）
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
//入栈，从前面添加
public void push(E e) {
addFirst(e);
}
//出栈，返回栈顶元素，从前面移除（会删除）
public E pop() {
return removeFirst();
}
// 删除链表中从first开始的第一次出现的指定元素
public boolean removeFirstOccurrence(Object o) {
return remove(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;
}
/**
* 返回链表中以指定位置开始的元素list-iterator
* - 在这个iterator创建后，如果这个链表在结构上被修改(除了通过iterator修改)
* 这个链表会报ConcurrentModificationException错误
*/
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);//[0,size]
return new ListItr(index);
}
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;//指定位置的上一个节点
private Node<E> next;//iterator的下一个节点
private int nextIndex;//iterator的下一个节点的角标
private int expectedModCount = modCount;
ListItr(int index) {
// 断言位置合法 isPositionIndex(index);
next = (index == size) ? null : node(index);//将iterator的下一个节点为指定位置的节点
nextIndex = index;//iterator的下一个节点的角标为指定位置的角标
}
//是否还有下一个节点
public boolean hasNext() {
return nextIndex < size;
}
//下一个节点的元素
public E next() {
checkForComodification();//检查链表结构是否被修改，如果被修改会报错
if (!hasNext())//没有下一个节点了
throw new NoSuchElementException();
lastReturned = next;//将上一次的节点给lastReturned
next = next.next;
nextIndex++;
return lastReturned.item;
}
//是否有上一个节点
public boolean hasPrevious() {
return nextIndex > 0;
}
//iterator的上一个节点元素
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;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
public 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);
else
linkBefore(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; //下一个节点，尾元素的next指向为null
Node<E> prev;//上一个节点，头元素的prev的指向为null
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();
}
}
//clone
@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" state
clone.first = clone.last = null;
clone.size = 0;
clone.modCount = 0;
// Initialize clone with our elements
for (Node<E> x = first; x != null; x = x.next)
clone.add(x.item);
return clone;
}
//将链表转化成元素列表
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;
}
/**
* 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；
* 返回数组的运行时类型为指定数组的类型。如果指定数组能容纳列表，则在其中返回该列表。
* 否则，分配具有指定数组的运行时类型和此列表大小的新数组。
* 如果指定数组能容纳列表，并有剩余空间（即数组比列表元素多），
* 则紧跟在列表末尾的数组元素会被设置为 null。（只有 在调用者知道列表不包含任何 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;
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// Write out size
s.writeInt(size);
// Write out all elements in the proper order.
for (Node<E> x = first; x != null; x = x.next)
s.writeObject(x.item);
}
@SuppressWarnings("unchecked")
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// Read in size
int size = s.readInt();
// Read in all elements in the proper order.
for (int i = 0; i < size; i++)
linkLast((E)s.readObject());
}
//1.8的方法，spliterator
@Override
public 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 increment
static final int MAX_BATCH = 1 << 25; // max batch array size;
final LinkedList<E> list; // null OK unless traversed
Node<E> current; // current node; null until initialized
int est; // size estimate; -1 until first needed
int expectedModCount; // initialized when est set
int batch; // batch size for splits
LLSpliterator(LinkedList<E> list, int est, int expectedModCount) {
this.list = list;
this.est = est;
this.expectedModCount = expectedModCount;
}
final int getEst() {
int s; // force initialization
final 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;
}
}
}