java 8流的内部迭代看起来如何

Question

我试图理解外部迭代器和内部迭代器的区别，外部迭代器使用迭代器来枚举它的元素

List<String> alphabets = Arrays.asList(new String[]{"a","b","b","d"});
         
for(String letter: alphabets){
   System.out.println(letter.toUpperCase());
}

上面的代码在后台执行如下操作：

List<String> alphabets = Arrays.asList(new String[]{"a","b","b","d"});    
Iterator<String> iterator = alphabets.listIterator();
while(iterator.hasNext()){
     System.out.println(iterator.next().toUpperCase());
}

但是对于内部迭代，一切都在后台完成，这对我来说是一个黑匣子，我想深入研究它。

就像下面的代码一样，迭代是在后台发生的，但到底发生了什么，以及与foreach循环相比有什么不同？

List<String> alphabets = Arrays.asList(new String[]{"a","b","b","d"});
alphabets.stream().forEach(l -> l.toUpperCase());

这是我对外部和内部迭代的理解，如果我错了，请指正。

Answer 1

内部迭代的全部意义在于迭代逻辑可以以不同的方式实现。

< code>Iterable的默认实现如下所示

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

因此，当一个可迭代的，例如一个集合，没有为每个实现提供时，这个继承的实现与外部迭代相同。

重写此默认实现有不同的原因。例如，Collections.synchronized....（...）方法之一返回的包装器有一个如下所示的实现：

@Override
public void forEach(Consumer<? super E> consumer) {
    synchronized (mutex) {c.forEach(consumer);}
}

它委托原始集合的＜code＞forEach＜/code＞实现执行它所做的任何操作，但在保持互斥的同时执行整个操作。换句话说，与外部迭代不同，外部迭代中代码必须关心自身的锁定，此实现免费提供同步。

另一个有趣的例子是Collections.unmodifiable....（...）包装器。

@Override
public void forEach(Consumer<? super E> action) {
    c.forEach(action);
}

乍一看，优势并不明显。但是，正如您在问题中所示，外部迭代是使用迭代器完成的，即使使用 for-each 语法也是如此。迭代器具有 remove 方法，因此每次对不可修改的包装器执行外部迭代时，原始集合的迭代器必须包装在另一个迭代器中，以防止调用方使用 remove（）。

相比之下，内部迭代不是通过契约修改集合。因此包装器可以委托给原始集合的foreach方法，这将做正确的事情。如果目标方法根本使用迭代器，则不需要迭代器周围的包装器。

例如。这是ArrayList的foreach方法：

@Override
public void forEach(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    final int expectedModCount = modCount;
    @SuppressWarnings("unchecked")
    final E[] elementData = (E[]) this.elementData;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        action.accept(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

因此，它不是基于迭代器的循环，而是迭代索引并直接访问其数组。

请注意，在可迭代对象（如集合上调用forEach，与在流上调用forEach不同。流允许链接影响终端操作开始时将发生什么的各种中间操作。当您不链接中间操作，只调用＜code＞forEach（…）时，该调用可能执行与＜code＞集合等价的操作。spliterator（）.forEachRemaining（…）由流实现自行决定。

这最终与在集合上调用foreach的代码路径不同，但对于合理的集合实现，这些代码路径的作用基本相同。此答案比较了ArrayList的不同变体，虽然存在细微差异，但迭代的基本方式（使用数组中的索引）是相同的。