迭代器模式/迭代器类

Question

我实现了一个简单的迭代器。只是想看看我有没有漏掉任何东西。

interface iterator<E>
    {
        boolean hasNext();

        E next();
    }

    class Iterator<E> implements iterator
    {
        E[] arr;

        int curPos = 0;

        @Override
        public boolean hasNext()
        {
            if (curPos >= arr.length || arr[curPos] == null) 
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        @Override
        public E next()
        {
            if(hasNext())
            {
                E res = arr[curPos];
                curPos++;
                return arr[curPos+1];
            }
            else
            {
                throw new runtimeException("No next element available !");
            }
        }

    }

问题：

1. 为什么我不应该使用Object而不是E/template？
2. 如何为二叉树制作迭代器。

除上述假设外，我还必须实现一个遍历算法，并试图找到下一个“遍历”后续程序是否存在？

Answer 1

我会用这种方式为数组编写一个迭代器：

import java.util.Iterator;
import java.util.NoSuchElementException;

public class ArrayIterator<E> implements Iterator<E> {

    private final E[] arr;
    private int currentIndex = 0;

    public ArrayIterator(E... arr) {
        if(arr == null) {
            throw new IllegalArgumentException("Array is null");
        }
        this.arr = arr;
    }

    public boolean hasNext() {
        return currentIndex < arr.length;
    }

    public E next() {
        if (! hasNext()) {
            throw new NoSuchElementException();
        }
        return arr[currentIndex++];
    }

    public void remove() {
        throw new UnsupportedOperationException("Not supported.");
    }

}

对于您的第二个问题:我假设您希望按顺序遍历树，并且节点没有链接到父节点，只链接到子节点。然后，您需要一个从根节点到当前节点的节点列表，如果节点已经被访问或没有访问，它也可以存储。

然后向左越深越好，将路径存储在节点列表中。这是您的第一个当前节点。当您需要下一个的时候，取它的父(从节点列表)。接下来将是该节点的正确子节点(如果有)或它自己的父节点。理解这一点的最好方法是拿出一张纸，画出不同的树，看看遍历是如何工作的。

Answer 2

因为这样，该代码的使用者就可以编写如下内容：

Iterator<Foo> iterator = new Iterator<Foo>();

//...

Foo theFoo = iterator.next();

而不必将类型对象的对象强制转换为Foo类型

Foo theFoo = (Foo)iterator.next();

它通过严格规定预期的对象类型来避免潜在的混淆。

Answer 3

下一个方法应该在迭代器到达终点时抛出一个异常。迭代器使用不当后得到NPE既不安全，也不方便。