Вопрос-ответ

In detail, how does the 'for each' loop work in Java?

Подробно, как работает цикл "для каждого" в Java?

Рассмотрим:

List<String> someList = new ArrayList<>();
// add "monkey", "donkey", "skeleton key" to someList
for (String item : someList) {
System.out.println(item);
}

Как бы выглядел эквивалентный for цикл без использования синтаксиса for each?


Новички в Java обычно сталкиваются с проблемами при попытке изменить исходные данные с помощью цикла foreach в новом стиле. Используйте Почему присвоение переменной итерации в цикле foreach не изменяет базовые данные? чтобы закрыть дубликаты этой распространенной проблемы. Обратите внимание, что другие языки с аналогичными конструкциями обычно имеют ту же проблему; например, см. Почему изменение переменной iteration не влияет на последующие итерации? о той же проблеме в Python.

Переведено автоматически
Ответ 1
for (Iterator<String> i = someIterable.iterator(); i.hasNext();) {
String item = i.next();
System.out.println(item);
}

Обратите внимание, что если вам нужно использовать i.remove(); в вашем цикле или каким-либо образом получить доступ к фактическому итератору, вы не можете использовать for ( : ) идиому, поскольку фактический итератор просто выводится.

Как было отмечено Денисом Буэно, этот код работает для любого объекта, который реализует Iterable интерфейс.

Кроме того, если правая часть for (:) идиомы является array, а не Iterable объектом, внутренний код использует счетчик индекса int и проверяет на array.length вместо этого. Смотрите Спецификацию языка Java .

Ответ 2

Конструкция for each также допустима для массивов. например

String[] fruits = new String[] { "Orange", "Apple", "Pear", "Strawberry" };

for (String fruit : fruits) {
// fruit is an element of the `fruits` array.
}

что по сути эквивалентно

for (int i = 0; i < fruits.length; i++) {
String fruit = fruits[i];
// fruit is an element of the `fruits` array.
}

Итак, общее резюме:

[nsayer] Ниже приведена более подробная форма того, что происходит:


for(Iterator<String> i = someList.iterator(); i.hasNext(); ) {
String item = i.next();
System.out.println(item);
}

Обратите внимание, что если вам нужно использовать
i.remove(); в вашем цикле или получить доступ к
фактическому итератору каким-либо образом, вы
не можете использовать идиому for ( : ), поскольку
фактический итератор - это просто
сделан вывод.


[Denis Bueno]


Это подразумевается в ответе nsayer , но стоит отметить, что синтаксис OP for (..) будет работать, когда "someList" - это все, что реализует java.lang.Итерируемый - это не обязательно должен быть список или какая-то коллекция из java.util. Следовательно, с этим синтаксисом можно использовать даже ваши собственные типы.


Ответ 3

Цикл for-each, добавленный в Java 5 (также называемый "расширенным циклом for"), эквивалентен использованию java.util.Iterator - это синтаксический сахар для того же самого. Следовательно, при чтении каждого элемента, по одному и по порядку, for-each всегда следует выбирать вместо итератора, так как это более удобно и лаконично.

For-each

for (int i : intList) {
System.out.println("An element in the list: " + i);
}

Итератор

Iterator<Integer> intItr = intList.iterator();
while (intItr.hasNext()) {
System.out.println("An element in the list: " + intItr.next());
}

Бывают ситуации, когда вы должны использовать Iterator напрямую. Например, попытка удалить элемент при использовании for-each может (приведет?) привести к ConcurrentModificationException.

For-each и for-loop: основные различия

Единственное практическое различие между for-loop и for-each заключается в том, что в случае индексируемых объектов у вас нет доступа к индексу. Пример, когда требуется базовый цикл for.:

for (int i = 0; i < array.length; i++) {
if(i < 5) {
// Do something special
} else {
// Do other stuff
}
}

Хотя вы могли бы вручную создать отдельную переменную index int с помощью for-each,

int idx = -1;
for (int i : intArray) {
idx++;
...
}

... это не рекомендуется, поскольку область видимости переменной не идеальна, а базовый for цикл - это просто стандартный и ожидаемый формат для данного варианта использования.

Для каждого по сравнению с циклом for: производительность

При доступе к коллекциям функция for-each выполняется значительно быстрее, чем доступ к массиву в базовом for цикле. Однако при доступе к массивам - по крайней мере, с примитивными массивами и массивами-оболочками - доступ через индексы значительно ускоряется.

Определение времени разницы между доступом к итератору и индексу для примитивных int-массивов

Индексы работают на 23-40 процентов быстрее итераторов при доступе к int или Integer массивам. Вот результат тестирования класса в нижней части этого поста, который суммирует числа в 100-элементном массиве primitive-int (A - итератор, B - индекс):

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)

Я также запускал это для Integer массива, и индексы по-прежнему являются явным победителем, но только на 18-25 процентов быстрее.

Для коллекций итераторы работают быстрее, чем индексы

Однако для List of Integers итераторы являются явным победителем. Просто измените int-массив в тестовом классе на:

List<Integer> intList = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100});

И внесите необходимые изменения в тестовую функцию (int[] to List<Integer>, length to size() и т.д.):

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,429,929,976 nanoseconds
Test B: 5,262,782,488 nanoseconds
A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,907,391,427 nanoseconds
Test B: 3,957,718,459 nanoseconds
A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,566,004,688 nanoseconds
Test B: 4,221,746,521 nanoseconds
A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,770,945,276 nanoseconds
Test B: 3,829,077,158 nanoseconds
A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,467,474,055 nanoseconds
Test B: 5,183,149,104 nanoseconds
A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,439,983,933 nanoseconds
Test B: 3,509,530,312 nanoseconds
A faster by 69,546,379 nanoseconds (1.4816434912159906% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,451,101,466 nanoseconds
Test B: 5,057,979,210 nanoseconds
A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)

В одном тесте они почти эквивалентны, но с коллекциями выигрывает итератор.

* Этот пост основан на двух ответах, которые я написал на Stack Overflow:

Еще немного информации: что эффективнее, цикл "для каждого" или итератор?

Полный класс тестирования

Я создал этот класс сравнения времени, необходимого для выполнения любых двух действий, после прочтения этого вопроса о Stack Overflow:

import  java.text.NumberFormat;
import java.util.Locale;

/**
&lt;P&gt;{@code java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt;

@see &lt;CODE&gt;&lt;A HREF=&quot;https://javalang.ru/questions/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;https://javalang.ru/questions/180158/how-do-i-time-a-methods-execution-in-java&lt;/A&gt;&lt;/CODE&gt;
**/

public class TimeIteratorVsIndexIntArray {

public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);

public static final void main(String[] tryCount_inParamIdx0) {
int testCount;

// Get try-count from a command-line parameter
try {
testCount = Integer.parseInt(tryCount_inParamIdx0[0]);
}
catch(ArrayIndexOutOfBoundsException | NumberFormatException x) {
throw new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x);
}

//Test proper...START
int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100};

long lStart = System.nanoTime();
for(int i = 0; i < testCount; i++) {
testIterator(intArray);
}

long lADuration = outputGetNanoDuration("A", lStart);

lStart = System.nanoTime();
for(int i = 0; i < testCount; i++) {
testFor(intArray);
}

long lBDuration = outputGetNanoDuration("B", lStart);

outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B");
}

private static final void testIterator(int[] int_array) {
int total = 0;
for(int i = 0; i < int_array.length; i++) {
total += int_array[i];
}
}

private static final void testFor(int[] int_array) {
int total = 0;
for(int i : int_array) {
total += i;
}
}
//Test proper...END

//Timer testing utilities...START
public static final long outputGetNanoDuration(String s_testName, long l_nanoStart) {
long lDuration = System.nanoTime() - l_nanoStart;
System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds");
return lDuration;
}

public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName) {
long lDiff = -1;
double dPct = -1.0;
String sFaster = null;
if(l_aDuration > l_bDuration) {
lDiff = l_aDuration - l_bDuration;
dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5);
sFaster = "B";
}
else {
lDiff = l_bDuration - l_aDuration;
dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5);
sFaster = "A";
}
System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)");
return lDiff;
}

//Timer testing utilities...END

}
Ответ 4

Вот ответ, который не предполагает знания итераторов Java. Он менее точный, но полезен для обучения.

Во время программирования мы часто пишем код, который выглядит следующим образом:

char[] grades = ....
for(int i = 0; i < grades.length; i++) { // for i goes from 0 to grades.length
System.out.print(grades[i]); // Print grades[i]
}

Синтаксис foreach позволяет записать этот общий шаблон более естественным и менее синтаксически шумным способом.

for(char grade : grades) {   // foreach grade in grades
System.out.print(grade); // print that grade
}

Кроме того, этот синтаксис допустим для таких объектов, как списки или наборы, которые не поддерживают индексацию массивов, но которые реализуют интерфейс Java Iterable.

java