21

我有一个 LinkedList 我需要来回迭代多次。我正在使用它来跟踪将动态创建的工作流中的一系列页面。这不符合我的预期。给定这个例子：

LinkedList<String> navigationCases;
navigationCases.add("page1");
navigationCases.add("page2");
navigationCases.add("page3");
navigationCases.add("page4");

ListIterator navigationItr = navigationCases.listIterator();
navigationItr.next(); // Returns page1
navigationItr.next(); // Returns page2
navigationItr.previous(); //Returns page2 again
navigationItr.next(); //Returns page2 again

我想也许我错误地构建了我的列表，或者错误地使用了迭代器，但是在阅读了文档之后，这似乎是设计使然：

ListIterator 没有当前元素；它的光标位置始终位于调用 previous() 将返回的元素与调用 next() 将返回的元素之间。

和：

(Next) 返回列表中的下一个元素。可以重复调用此方法以遍历列表，或与调用 previous 混合调用以来回移动。（请注意，交替调用 next 和 previous 将重复返回相同的元素。）

因此，在阅读完本文后，很清楚为什么我的代码的行为方式如此。我只是不明白为什么它应该这样工作。甚至 remove 似乎也在向后弯曲以适应这种实现：

请注意，remove() 和 set(Object) 方法不是根据光标位置定义的；它们被定义为对调用 next() 或 previous() 返回的最后一个元素进行操作。

从概念上讲，LinkedList 似乎很好地模拟了我的工作流案例，但我不能使用以这种方式运行的迭代器。我在这里遗漏了什么，还是我应该编写自己的课程来维护一个案例列表并浏览它们？

4

3 回答 3

12

这应该做你的工作：

public class Main {
    public static void main(String[] args) {
        final LinkedList<String> list = new LinkedList<String> ();

        list.add ("1"); list.add ("2"); list.add ("3"); list.add ("4");

        final MyIterator<String> it = new MyIterator (list.listIterator());

        System.out.println(it.next());
        System.out.println(it.next ());
        System.out.println(it.next ());
        System.out.println(it.previous ());
        System.out.println(it.previous ());
        System.out.println(it.next ());
    }

    public static class MyIterator<T> {

        private final ListIterator<T> listIterator;

        private boolean nextWasCalled = false;
        private boolean previousWasCalled = false;

        public MyIterator(ListIterator<T> listIterator) {
            this.listIterator = listIterator;
        }

        public T next() {
            nextWasCalled = true;
            if (previousWasCalled) {
                previousWasCalled = false;
                listIterator.next ();
            }
            return listIterator.next ();
        }

        public T previous() {
            if (nextWasCalled) {
                listIterator.previous();
                nextWasCalled = false;
            }
            previousWasCalled = true;
            return listIterator.previous();
        }

    }   
}

和一个小提琴。

于 2012-11-20T22:44:01.133 回答
2

ListIterator 旨在以这种方式运行。请参阅 ShyJ 答案下方的对话以了解基本原理。

我发现这种行为非常愚蠢，而是写了一个非常简单的替代方案。这是带有 ArrayLists 扩展函数的 Kotlin 代码：

class ListIterator<E>(var list: ArrayList<E>) : Iterator<E> {

    private var cursor: Int = 0

    fun replace(newList: ArrayList<E>) {
        list = newList
        cursor = 0
    }

    override fun hasNext(): Boolean {
        return cursor + 1 < list.size
    }

    override fun next(): E {
        cursor++
        return current()
    }

    fun hasPrevious(): Boolean {
        return 0 <= cursor - 1
    }

    fun previous(): E {
        cursor--
        return current()
    }

    fun current(): E {
        return list[cursor]
    }

}

fun <E> ArrayList<E>.listFlippingIterator() = ListIterator(this)

如果您希望包含删除功能，我强烈建议您编写 API 以明确指示迭代器是否应该删除左侧或右侧，例如通过将这些方法定义为removeNext()和removePrevious()。

于 2017-12-18T12:52:26.370 回答
-1

做这样的事情（伪代码）——

class SkipIterator extends ListIterator {

    public E previous(){
        E n = super.previous();
        return super.previous();
    }

    ...

}

然后：

LinkedList<String> navigationCases;
navigationCases.add("page1");
navigationCases.add("page2");
navigationCases.add("page3");
navigationCases.add("page4");

SkipIterator navigationItr = (SkipIterator)navigationCases.listIterator();
navigationItr.next(); // Returns page1
navigationItr.next(); // Returns page2
navigationItr.previous(); // Returns page1

干杯

于 2012-11-20T22:28:10.730 回答