Java：为什么迭代器不可复制

Question

我认为 Iterator.copy() 将是一个非常方便的函数。您可以以更好的方式实现迭代器过滤器。

例如，Google 的 Java Collection 中 filter（和类似）函数使用 UnmodifyingIterator（它只是一个没有 Iterator 的Iterator）的唯一原因code>remove) 是因为您无法实现这样的过滤器 Iterator，否则无法在某个时刻复制它。 （实际上，这在当前接口中是不可能的；请您自己尝试一下。）

另一个优点是您可以在 for-each-循环中使用迭代器：因为可复制迭代器也将自动成为可迭代器。另请参阅此问题。目前，不允许这样做的主要设计原因是因为实现了 Iterable 和 Iterator的 Iterator 。迭代器（）{返回这个； } 将使迭代器无效。通过使用 copy 函数，它就像 Iterator一样简单。迭代器() { 返回复制(); } 并且它不会使原始迭代器无效。因此，没有理由不再允许这样做。

有什么理由吗？只是为了让实施变得更简单吗？

Answer 1

尽管通常是这样，但迭代器理论上不必链接到集合。例如，输入流上的复制方法很难实现，并且很容易导致模糊的内存问题。

Answer 2

Iterator 表示来自源的流中的位置（Java 中的 Iterable），并且不保证可以复制甚至访问流的源。

例如，当字节从网络服务器流式传输时，您可能会迭代它们，在这种情况下，不可能告诉网络服务器中流“从这个位置开始，我希望您向我发送相同的字节两次，但是按照我的要求异步进行。”

流只有一个，无法复制。

您通常看到的大多数 Iterator 都位于 Collection 上，这一事实是偶然的。

Answer 3

Google 拥有 UnmodifyingIterator 的唯一原因是基本上保证其集合的不变性。他们确保您无法更改集合的内部状态。

不要忘记迭代器的最初想法是它是遍历过程中指向当前元素的指针，并且它管理到下一个/上一个遍历（对于双向链接迭代器来说是反向的）到它的下一个/上一个元素。

迭代器不可克隆并没有实际原因，很简单，克隆迭代器仍然意味着让迭代器指向相同的集合元素（除了它现在位于两个不同的地址空间中）。除非您希望克隆的迭代器指向另一个集合，否则没有意义。

Answer 4

我想要这样的东西，这就是我所做的（基于 Lambdaj 上完成的一些工作）。
主要缺陷是这个迭代器基本上会用迭代器的所有假定内容填充一个列表，这可能会占用大量内存。

为什么我使用 List，因为有时 Iterator 会按特定顺序进行迭代，因此“子Iterators”必须执行相同的操作（并且 ListIterator< /code> 在这里确实对我有帮助）。

public class IterableIterator<T> implements Iterable<T>, Iterator<T> {
    //The content of the given iterator. Will be filled by its iterators.
    private final List<T> iteratorContent = new ArrayList<T>();
    private final Iterator<T> originalIterator;
    private final Iterator<T> innerIterator;

    public IterableIterator(Iterator<T> originalIterator) {
        this(originalIterator, false);
    }

    public IterableIterator(Iterator<T> originalIterator, boolean cache) {
        if (originalIterator == null) {
            throw new IllegalArgumentException("Parameter can't be null");
        }

        this.originalIterator = originalIterator;
        if (cache) {
            while (originalIterator.hasNext()) {
                iteratorContent.add(originalIterator.next());
            }
        }

        innerIterator = iterator();
    }

    @Override
    public Iterator<T> iterator() {
        return new IteratorIterator();
    }

    @Override
    public boolean hasNext() {
        return innerIterator.hasNext();
    }

    @Override
    public T next() {
        return innerIterator.next();
    }

    @Override
    public void remove() {
        innerIterator.remove();
    }

    private class IteratorIterator implements Iterator<T> {
        private ListIterator<T> innerIterator = iteratorContent.listIterator();

        @Override
        public boolean hasNext() {
            return innerIterator.hasNext() || originalIterator.hasNext();
        }

        @Override
        public T next() {
            if (!innerIterator.hasNext() && originalIterator.hasNext()) {
                T item;
                synchronized (originalIterator) {
                    item = originalIterator.next();
                    iteratorContent.add(item);
                }
                innerIterator = iteratorContent.listIterator(innerIterator.nextIndex());
            }
            if (innerIterator.hasNext()) {
                try {
                    return innerIterator.next();
                } catch (ConcurrentModificationException e) {
                    //Quick and dirty solution if you have a concurrent modification.
                    //It can't happen from the outside, so you can easily suppose that another originalIterator
                    //from this class has been called and had added elements to the list.
                    //Best thing to do, reset the originalIterator to the current position.
                    innerIterator = iteratorContent.listIterator(innerIterator.nextIndex());
                    return innerIterator.next();
                }
            }

            throw new NoSuchElementException();
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }
}

Answer 5

作为为什么要复制迭代器的简单示例，请考虑以下代码，该代码在单个数组中查找第一对匹配值。

for(int i=0;i<size;i++)
{
  x = array[i];

  for(int j=i+1;j<size;j++)
  {
    y = array[j];
    if(x == y)
    {
      doSomething();
      break;
    }
}

注意“j=i+1”。这就是迭代器遇到问题的地方。哦，好吧，解决方法在 Java 中似乎相当常见......

Answer 6

您始终可以实现自己的实现 Iterator 的 CopyableIterator。然后你可以做

new CopyableItereator(collection);

类将像这样

class CopyableIterator implements Iterator{
Iterator iterator;
Collection collection;
int index=0;

public CopyableIterator(Collection collection){
super();
this.collection = collection;
this.iterator = collection.iterator();
}

public CopyableIterator(Collection collection, int index){
super();
this.collection =collection;
this.iterator = collection.iterator();
this.advanceToIndex(iterator,index); //This function just moves the iterator till the index.
this.index=index;
}

//Override the functions of Iterator here returning iterator.function()

@Override
public Object next(){
index++;
return this.iterator.next();
}

public CopyableIterator copy(){
return new CopyableIterator(this.collection,this.index)

}

}

免责声明：这大致是类。它还没有经过测试。

Answer 7

复制 Iterator 到底意味着什么？您的意思是它应该能够像它自己一样创建一个新的迭代器，除了从头开始？这是 Iterable 的职责...重复该功能是没有意义的，特别是考虑到迭代器的有状态性质...它只会让事情变得混乱。

您会期望发生什么

Iterator<Foo> iter = someIterable.iterator();
iter.next();
iter.next();
for (Foo foo : iter) {
  ...
}

如果您写道：您希望 for 循环迭代迭代器将返回的每个项目，还是除了前两个之外的每个项目， ？您是否希望 for 循环完成后迭代器为空？

Answer 8

有什么理由吗？只是为了让实现变得更简单？

设计和实现支持复制操作的迭代器包装类会很简单。但我不确定它是否普遍有用，尤其是因为在一般情况下这将是一项昂贵的操作。仅此一点就足以让 Java 设计者不想将 copy() 添加到 Iterator 接口中。

FOLLOWUP

这就是我正在考虑的事情：

public class CopyableIterator<T> implements Iterator<T> {
    private Iterator<T> it;
    private List<T> copy = new ArrayList<T>();
    private int pos;
    public CopyableIterator(Iterator<T> it) {
        while (it.hasNext()) {
            copy.append(it.next());
        }
        this.it = copy.iterator();
    }
    public T next() {
        T res = next();
        pos++;
        return res;
    }
    public boolean hasNext() {
        return it.hasNext();
    }
    public Iterator<T> copy() {
        return copy.sublist(pos, copy.size()).iterator();
    }
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

推理是这样的：

• 如果我包装一个不透明的 Iterator，那么仅 我复制它的方法是使用 next() 和 hasNext() 读取它，并从中构造副本 Iterator 。

• 但我必须在开始使用原始迭代器之前执行此操作。

• 执行此操作的简单方法是在开始使用迭代器之前制作迭代器内容的副本。 （这可以通过惰性增量复制来完成，但实现可能会变得非常复杂......尤其是当您考虑复制复制的迭代器时。）

另一个答案中提出的方法仅限于普通集合迭代器。如果您有一个包装的迭代器，或者来自其他源的迭代器（例如）没有实现Iterable，那么您就完蛋了。

即使有这个前提条件，上面的方法也不会返回迭代器的真实副本。相反，它为底层集合返回一个新的迭代器。这是一个重要的区别。除非您实际复制迭代的元素引用，否则不能保证迭代器将返回相同的序列。查看 Concurrent... 集合类型的迭代器的记录行为。

Answer 9

ILMTitan 和 Christoffer Hammarström 暗示但没有具体说明复制流可能是不可能的，因为它要求流元素具有复制函数的实现，以便保存可复制迭代器所需的状态。意识到元素可能是可变的（或引用动态值），并且它们可能引用需要自定义复制功能的其他结构和语义。

因此，可复制迭代器与可复制流元素不正交，因此这就是可复制迭代器通常不可能的原因。

另一个更模糊的原因是复制行为对内存分配和释放有副作用。即使流元素的复制函数也可能有其他副作用。

另一个原因是编译为汇编语言时可能无法进行某些低级优化。

Answer 10

创建迭代器是为了使用该集合支持的数据一次遍历集合中的所有对象。

Iterator 几乎总是使用私有内部类来实现，该内部类可能使用属于外部类一部分的状态。因此，如果不编写自己的 Collection （或其他内容），您就无法真正修改 Iterator 的行为。

复制迭代器可能会导致许多新问题，例如与后备集合不同步。

Answer 11

您可能无法复制迭代器 - 它基本上没有意义。对于某些人来说，这从 Iterator 接口中显而易见，但让我们用一个具体的示例来演示它。事实上，让我们用一个关于具体的例子来演示。

这是混凝土棒上的混凝土迭代器的图片。在我们的例子中，迭代意味着使用撬棍将其从撬棍上折断。现在，请注意：

• 该栏不是片段的集合（尽管其中一些有缺陷）：我们在迭代时创建片段。
• 通过迭代器（next()）进行迭代的结果永远不可能是条形图另一次迭代的结果。结果已从中删除。
• 迭代可能会产生不同的片段，具体取决于天气、施加的力的大小，或者可能是某种热噪声（想想：随机性）。
• 通过迭代器（next()）进行迭代的结果永远不可能是条形图另一次迭代的结果 - 因为精确迭代结果的概率空间是连续的，并且没有特定的结果片段具有连续性。非零概率测度。

上述任何一个都应该说服你不要尝试“复制迭代器”，那是愚蠢的......