Java 传统循环和 for-each 循环有什么区别？

What is a difference between traditional loop and for-each loop?

提问by shanks

I wonder if there is a difference between these:

我想知道这些之间是否有区别：

ArrayList<Example> list = new ArrayList<Example>

1-)

1-)

for(int i = 0; i < list.size(); i++) {
    list.get(i).doSomething();
}

2-)

2-)

for(Example example : list) {
    example.doSomething();
}

If there is not any difference which one is more common or efficient?

如果没有任何区别，哪个更常见或更有效？

采纳答案by Jaroslaw Pawlak

Traditional loop

传统循环

for (int i = 0; i < list.size(); i++) {
    list.get(i).doSomething();
}

• allows to modify the list, e.g.:
  • you can add extra element at the end of list and it will be also iterated through
• you know the index
  • can be used to refer to another list of the same size
  • can be used to refer to previous/next element
• efficient only in RandomAccesslists
  • in case of LinkedListin every iteration of the loop, get(i)will have to iterate over all elements starting from head/tailto i
• works only with Listsince List#get(int)is used
• error prone, a lot of things that can go wrong, e.g.:
  • i = 0;instead of int i = 0;- will refer to variable declared before the loop, possible side effects outside of the loop
  • >instead of <- loop will not execute
  • j++instead of i++- infinite loop
  • .get(j)instead of .get(i)- will always get the same element

• 允许修改列表，例如：
  • 你可以在列表的末尾添加额外的元素，它也会被迭代
• 你知道指数
  • 可用于引用另一个相同大小的列表
  • 可用于引用上一个/下一个元素
• 仅在RandomAccess列表中 有效
  • 如果LinkedList在循环的每次迭代中，get(i)将不得不迭代所有元素，从head/tail到i
• 仅适用于List因为List#get(int)使用
• 容易出错，很多事情都可能出错，例如：
  • i = 0;而不是int i = 0;- 将引用在循环之前声明的变量，循环外可能的副作用
  • >而不是<- 循环不会执行
  • j++而不是i++- 无限循环
  • .get(j)而不是.get(i)- 将始终获得相同的元素

For-each loop

For-each 循环

for (Example example : list) {
    example.doSomething();
}

• does not allow to modify the list
  • trying to do so will most likely result in ConcurrentModificationException
• you don't know the index of the element
  • you cannot refer to previous/next element
• efficient in all cases because uses Iteratorspecific for the collection
  • efficient in case of LinkedList
• works not only with every Collection, but with every Iterablesince Iterable#iterator()is used
  • you can easily replace Listwith a Set- no changes to the loop required
  • you can easily replace with your own class, it just has to implement Iterable
• more robust (less code, fewer special characters)

• 不允许修改列表
  • 尝试这样做很可能会导致 ConcurrentModificationException
• 你不知道元素的索引
  • 你不能引用上一个/下一个元素
• 在所有情况下都有效，因为Iterator特定于集合的 用途
  • 有效的情况下 LinkedList
• 不仅适用于 every Collection，而且适用于 every IterablesinceIterable#iterator()被使用
  • 您可以轻松替换List为Set- 无需更改循环
  • 你可以很容易地用你自己的类替换，它只需要实现 Iterable
• 更健壮（更少的代码，更少的特殊字符）

Summary

概括

for-eachloop wins with a score 3 : 2.

for-eachLoop 以 3 : 2 的比分获胜。

The only reason to use a traditional loop is when:

使用传统循环的唯一原因是：

• the index of element is required, or
• the list has to be modified

• 元素的索引是必需的，或
• 列表必须修改

回答by Sebastian S

The second one works with every type of (potentially unordered) Iterable, as it doesn't rely on random access, i.e. get(i).

第二个适用于所有类型的（可能是无序的）Iterable，因为它不依赖于随机访问，即get(i).

回答by Andrew Tobilko

for(:)statement is a read-only loop. You cannot change a collection within this loop. Also you cannot use more than one element.

for(:)语句是一个只读循环。您不能在此循环中更改集合。此外，您不能使用多个元素。

The traditional forstatement doesn't have such limits.

传统的for语句没有这样的限制。

回答by Mohammed Aouf Zouag

They are basically the same, but for-each (the second one) has certain restrictions.

它们基本相同，但是 for-each（第二个）有一定的限制。

1. It can be used for accessingthe array elements but not for modifyingthem.

2. It is not usablefor loops that must iterate over multiple collections in parallel—for example, to compare the elements of two arrays.

3. It can be used only for a single element access and cannot be used to compare successive elements in an array. It is a forward-onlyiterator. If you want to access only a few elements of the array, you would need to use the traditional for loop.

1. 它可用于访问数组元素，但不能用于修改它们。

2. 它不适用于必须并行迭代多个集合的循环——例如，比较两个数组的元素。

3. 它只能用于单个元素访问，不能用于比较数组中的连续元素。它是一个只进迭代器。如果只想访问数组的几个元素，则需要使用传统的 for 循环。