java - 为什么 Java 不允许在迭代器上使用 foreach(仅在可迭代对象上)？

Question

这个问题在这里已经有了答案:

关闭 10年前.

Possible Duplicate:
Why is Java's Iterator not an Iterable?

Idiomatic way to use for-each loop given an iterator?

Can we use for-each loop for iterating the objects of Iterator type?

据我所知，foreach 循环是 Java 5 中添加的语法糖。所以

Iterable<O> iterable;
for(O o : iterable) {
    // Do something
}

基本上会产生与

相同的字节码

Iterable<O> iterable;
for(Iterator<O> iter = iterable.iterator(); iter.hasNext(); /* NOOP */) {
    O o = iter.next();
    // Do something
}

但是，如果我一开始没有可迭代对象，而只有一个迭代器(比如说，因为一个类提供了两个不同的迭代器)，我就不能使用语法糖 foreach 循环。显然我仍然可以进行简单的旧样式迭代。但是，我实际上想做:

Iterator<O> iter;
for(O o : iter /* Iterator<O>, not Iterable<O>! */) {
     // Do something
}

当然我可以做一个假的Iterable:

class Adapter<O> implements Iterable<O> {
    Iterator<O> iter;

    public Adapter(Iterator<O> iter) {
        this.iter = iter;
    }

    @Override
    public Iterator<O> iterator() {
        return iter;
    }
}

(这实际上是对 Iterable API 的丑陋滥用，因为它只能迭代一次!)

如果它是围绕 Iterator 而不是 iterable 设计的，可以做很多有趣的事情:

for(O o : iterable.iterator()) {} // Iterate over Iterable and Collections

for(O o : list.backwardsIterator()) {} // Or backwards

Iterator<O> iter;
for(O o : iter) {
    if (o.something()) { iter.remove(); }
    if (o.something()) { break; }
}
for(O : iter) { } // Do something with the remaining elements only.

有人知道为什么语言是这样设计的吗？如果一个类同时实现 Iterator 和 Iterable，为了避免歧义？为了避免假定“for(O o : iter)”将处理所有元素两次(并且忘记获取新的迭代器)的程序员错误？还是有其他原因？

还是有一些我不知道的语言技巧？

Answer 1

所以我现在有了一个比较合理的解释:

短版:因为语法也适用于没有迭代器的数组。

如果语法是按照我的建议围绕 Iterator 设计的，它将与数组不一致。让我给出三个变体:

A) 由 Java 开发人员选择:

Object[] array;
for(Object o : array) { }
Iterable<Object> list;
for(Object o : list) { }
Iterator<Object> iter;
while(iter.hasNext()) { Object o = iter.next(); }

行为方式相同，并且在数组和集合之间高度一致。然而，迭代器必须使用经典的迭代风格(至少不会导致错误)。

B) 允许数组和Iterators:

Object[] array;
for(Object o : array) { }
Iterable<Object> list;
for(Object o : list.iterator()) { }
Iterator<Object> iter;
for(Object o : iter) { }

现在数组和集合不一致；但是数组和 ArrayList 密切相关，应该表现相同。现在，如果在任何时候，该语言将被 扩展 以制作例如数组实现了Iterable，就变得不一致了。

C) 允许所有三个:

Object[] array;
for(Object o : array) { }
Iterable<Object> list;
for(Object o : list) { }
Iterator<Object> iter;
for(Object o : iter) { }

现在，如果我们最终处于不清楚的情况下，当有人实现 both Iterable 和 Iterator 时(for 循环是否应该得到一个新的迭代器或迭代当前 - 在树状结构中很容易发生!？!)。不幸的是，一个简单的 tie-braker ala “Iterable beats Iterator”是行不通的:它突然引入了运行时与编译时间差异和泛型问题。

现在突然间，我们需要注意是要迭代集合/可迭代对象还是数组，此时我们以大困惑为代价获得了很少的好处。

Java (A) 中“for each”的方式非常一致，它导致的编程错误非常少，并且允许将来可能将数组转换为常规对象。

有一个变体 D) 可能也可以正常工作:for-each 仅适用于迭代器。最好通过向原始数组添加 .iterator() 方法:

Object[] array;
for(Object o : array.iterator()) { }
Iterable<Object> list;
for(Object o : list.iterator()) { }
Iterator<Object> iter;
for(Object o : iter) { }

但这需要更改运行时环境，而不仅仅是编译器，并且会破坏向后兼容性。另外，上面提到的混淆仍然存在，

Iterator<Object> iter;
for(Object o : iter) { }
for(Object o : iter) { }

只对数据进行一次迭代。