共同学习Java源代码--数据结构--LinkedList类(七)

    public ListIterator<E> listIterator(int index) {
        checkPositionIndex(index);
        return new ListItr(index);

    }

这个方法首先检查参数是否越界，然后返回一个内部类ListItr实例。

下面看内部类Listltr类：

    private class ListItr implements ListIterator<E> {

这个类实现ListIterator接口。
        private Node<E> lastReturned;

定义一个私有成员变量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;
        }
这是构造方法，接收传来的下标也就是上面那个方法传进来的参数，如果index就是最后一个节点，那么next变量就设为空，否则next变量设为index所处的节点，然后将nextIndex变量设为index值。

        public boolean hasNext() {
            return nextIndex < size;
        }
判断有没有下一个元素的方法，就是判断nextIndex是否小于链表长度。

        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();
            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }
获取下一个节点元素的方法。

首先检查并发异常，然后判断是否有下一个节点，如果没有就抛出异常。

然后将lastReturned变量指向next元素，然后将next元素指向next的下一个元素，然后nextIndex自增。

最后返回lastReturned的内容。

        public boolean hasPrevious() {
            return nextIndex > 0;
        }
判断有没有上一个元素的方法，就是判断nextIndex是否大于0。

        public E previous() {
            checkForComodification();
            if (!hasPrevious())
                throw new NoSuchElementException();
            lastReturned = next = (next == null) ? last : next.prev;
            nextIndex--;
            return lastReturned.item;
        }
这个是返回上一个元素内容的方法。

首先检查是否有并发异常，然后判断是否有上一个节点，没有的话就抛出异常。

然后判断next是否为空？如果为空就将外部类的last节点赋引用给next，如果next不为空，就将next的上一个节点给给next。然后将next给lastReturned。
然后nextIndex自减。最后返回lastReturn的内容。

        public int nextIndex() {
            return nextIndex;
        }
这个方法返回nextIndex。

        public int previousIndex() {
            return nextIndex - 1;
        }
这个方法返回nextIndex减一，也就是上一个元素下标。
        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++;
        }
这个方法是删除的方法。

首先检查并发异常。

然后判断lastReturned是否为空，如果为空就抛出异常。

然后创建临时变量lastNext，赋引用为lastReturned的下一个节点。然后将lastReturned元素删除。

如果next元素就是lastReturned元素，那么就将lastNext也就是要删除的节点的下一个节点作为next，如果next不是lastReturned，nextIndex自减。

最后lastReturned为空，expectedModCount自减。

        public void set(E e) {
            if (lastReturned == null)
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.item = e;
        }
这个是赋值方法，首先判断lastReturned是否为空，如果为空就抛出异常。

然后检查并发异常。最后将lastReturned的内容设为方法参数。

        public void add(E e) {
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e);
            else
                linkBefore(e, next);
            nextIndex++;
            expectedModCount++;
        }
这个方法是添加元素的方法，先检查并发异常。

然后将lastReturned设为空。

然后判断next是否为空，如果为空，就将参数放在最后，如果不为空，就将参数放在next之前。

最后nextIndex和expectedModeCount自增。

        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();
        }

这个方法判断是否出现并发异常，就是判断两个modCount是否相等。
    }

其实lastReturned节点就是刚刚“”跳过“”的节点。