Java 集合 LinkedList的ListIterator

Java 集合 LinkedList的ListIterator

@author ixenos

摘要：ListIterator<E>是继承自Iterator<E>的接口、listIterator(int index)源码分析、利用ListItr实现的降序迭代

ListIterator<E>是继承自Iterator<E>的接口

---

　　故，ListIterator注意点：

　　1.迭代器不存储所有元素的引用，只有两个指针，一个指向上一个返回得到的元素，另一个下一个未涉足的元素；

　　2.迭代开始前先同步内外modCount，迭代过程中检查是否同步，如果外部结构改变，则迭代快速失败(fast-fails机制)；

　　3.ListIterator可以算半个LinkedList视图了，因为在迭代的途中还可以修改外部结构（add、remove）

listIterator(int index)源码分析

---

listIterator

public ListIterator<E> listIterator(int index)

返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。

参数：

index - 要从列表迭代器返回的第一个元素的索引（通过调用 next 方法）

返回：

此列表中的元素的 ListIterator（按适当顺序），从列表中指定位置开始

抛出：

IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index > size())

通过：

　　　内部类private class ListItr implements ListIterator<E> 实现

//迭代器不存储数值！是每迭代一次返回一次 
// LinkedList中功能强大的ListIterator方法

  public ListIterator<E> listIterator(int index) {
        checkPositionIndex(index);
        return new ListItr(index);  //调用内部类ListItr的匿名对象
    }

//把ListIterator接口送给内部类实现是为了与Iterator接口兼容，因为ListIterator接口继承自Iterator接口
    private class ListItr implements ListIterator<E> { //实现了ListIterator接口
        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();     //先确定外部modCount没变
            if (lastReturned == null)
                throw new IllegalStateException();

            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;    //删除外部元素modCount++所以内部的expectedModCount也++来同步
        }

        public void set(E e) {
            if (lastReturned == null) //先确定外部modCount没变
                throw new IllegalStateException();
            checkForComodification();
            lastReturned.item = e;
        }

        public void add(E e) {
            checkForComodification();
            lastReturned = null;
            if (next == null)
                linkLast(e); //如果next指针在队尾则直接加在队尾
            else
                linkBefore(e, next); //否则插入到next指针指向元素的前面
            nextIndex++;
            expectedModCount++; //删除外部元素modCount++所以内部的expectedModCount也++来同步

        }

        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);  //如果action为空则抛出空指针异常
            while (modCount == expectedModCount && nextIndex < size) {
                action.accept(next.item);
                lastReturned = next;
                next = next.next;
                nextIndex++;
            }
            checkForComodification();
        } 

//外部结构修改则迭代快速失败fast-fails
        final void checkForComodification() {  
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
}

利用ListItr实现的降序迭代

---

descendingIterator

public Iterator<E> descendingIterator()

返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。元素将按从最后一个（尾部）到第一个（头部）的顺序返回。

实质就是在关键操作修改了指针

返回：

以逆向顺序在此双端队列中的元素上进行迭代的迭代器

从以下版本开始：

1.6 

  /**降序迭代
     * @since 1.6
     */
// sort 是顺序ascending 表示升descending 表示降
    public Iterator<E> descendingIterator() {
        return new DescendingIterator();
    }

    /**
     * Adapter to provide descending iterators via ListItr.previous
     */
//利用LisItr实现降序迭代
    private class DescendingIterator implements Iterator<E> {
        private final ListItr itr = new ListItr(size());  
        public boolean hasNext() {
            return itr.hasPrevious();    //利用原有方法，改造了一下return
        }
        public E next() {
            return itr.previous();    //利用原有方法，改造了一下return
        }
        public void remove() {
            itr.remove();
        }
    }