Как работает цикл Java для каждого цикла?

Рассматривать:

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

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

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

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

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

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

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

     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 i = someList.iterator(); i.hasNext(); ) { String item = i.next(); System.out.println(item); } 

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

    [Денис Буено]

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

    Вот ответ, который не предполагает знания iteratorов 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.

    Цикл foreach , добавленный в Java 5 (также называемый «расширенный для цикла»), эквивалентен использованию синтаксического сахара java.util.Iterator –it для одного и того же. Поэтому при чтении каждого элемента по одному и по порядку всегда следует выбирать foreach над iteratorом, поскольку он более удобен и краток.

    для каждого

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

    Итератор

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

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

    foreach vs. for : Основные различия

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

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

    Хотя вы можете вручную создать отдельный индекс int-variable с foreach ,

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

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

    foreach vs. for : Производительность

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

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

    Индексы на 23-40% быстрее, чем iteratorы при доступе к массивам int или Integer . Вот результат из classа тестирования в нижней части этого сообщения, который суммирует числа в массиве primitive-int из 100 элементов (A - это iterator, 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 процентов быстрее.

    Для коллекций iteratorы быстрее индексов

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

     List 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[] в List , 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) 

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

    * Это сообщение основано на двух ответах, которые я написал в «Переполнение стека»:

    • Использование и синтаксис для каждого цикла в Java

    • Должен ли я использовать Iterator или forloop для повторения?

    Дополнительная информация: что более эффективно, для каждого цикла или iteratorа?

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

    Я создал этот class compare-the-time-it-take-to-do-any-two-things после прочтения этого вопроса в Stack Overflow:

     import java.text.NumberFormat; import java.util.Locale; /** <P>{@code java TimeIteratorVsIndexIntArray 1000000}</P> @see <CODE><A HREF="https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java">https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java</A></CODE> **/ 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 } , import java.text.NumberFormat; import java.util.Locale; /** <P>{@code java TimeIteratorVsIndexIntArray 1000000}</P> @see <CODE><A HREF="https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java">https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java</A></CODE> **/ 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 } 

    Для каждого цикла в Java используется базовый механизм iteratorа. Таким образом, он идентичен следующему:

     Iterator iterator = someList.iterator(); while (iterator.hasNext()) { String item = iterator.next(); System.out.println(item); } 

    В функциях Java 8 вы можете использовать это:

     List messages = Arrays.asList("First", "Second", "Third"); void forTest(){ messages.forEach(System.out::println); } 

    Вывод

     First Second Third 

    Это подразумевается ответом nsayer, но стоит заметить, что синтаксис OP для (..) будет работать, когда «someList» – это что- то, что реализует java.lang.Iterable – это не должен быть список или некоторая коллекция из java.util. Таким образом, даже ваши собственные типы могут использоваться с этим синтаксисом.

    Синтаксис цикла foreach:

     for (type obj:array) {...} 

    Пример:

     String[] s = {"Java", "Coffe", "Is", "Cool"}; for (String str:s /*s is the array*/) { System.out.println(str); } 

    Вывод:

     Java Coffe Is Cool 

    ПРЕДУПРЕЖДЕНИЕ. Вы можете получить доступ к элементам массива с помощью цикла foreach, но вы НЕ можете их инициализировать. Для этого используйте исходный цикл.

    ПРЕДУПРЕЖДЕНИЕ. Вы должны соответствовать типу массива с другим объектом.

     for (double b:s) // Invalid-double is not String 

    Если вы хотите редактировать элементы, используйте for цикл for :

     for (int i = 0; i < s.length-1 /*-1 because of the 0 index */; i++) { if (i==1) //1 because once again I say the 0 index s[i]="2 is cool"; else s[i] = "hello"; } 

    Теперь, если мы сбросим s на консоль, мы получим:

     hello 2 is cool hello hello 

    Конструкция цикла Java «для каждого» допускает итерацию над двумя типами объектов:

    • T[] (массивы любого типа)
    • java.lang.Iterable

    Интерфейс Iterable имеет только один метод: Iterator iterator() . Это работает над объектами типа Collection потому что интерфейс Collection расширяет Iterable .

    Ниже приведено понятие цикла foreach, упомянутого в Википедии:

    Однако, в отличие от других для контурных контуров, foreach-петли обычно не поддерживают явный счетчик : они по существу говорят «сделайте это ко всему в этом наборе», а не «сделайте это x раз». Это позволяет избежать ошибок, возникающих по очереди, и упрощает чтение кода.

    Таким образом, концепция цикла foreach описывает, что в цикле не используется явный счетчик, что означает, что нет необходимости использовать индексы для перемещения в списке, тем самым он избавляет пользователя от посторонней ошибки. Чтобы описать общую концепцию этой погрешности, давайте возьмем пример цикла для перемещения в списке с использованием индексов.

     // In this loop it is assumed that the list starts with index 0 for(int i=0; i 

    Но предположим, что если список начинается с индекса 1, то этот цикл будет генерировать исключение, так как он не найдет ни одного элемента в индексе 0, и эта ошибка будет вызвана ошибкой «один за другим». Поэтому, чтобы избежать этой ошибки, используется концепция цикла foreach. Могут быть и другие преимущества, но это то, что я считаю основной концепцией и преимуществом использования цикла foreach.

    Как определено в JLS for-each, цикл может иметь две формы:

    1. Если тип выражения является подтипом Iterable тогда перевод выглядит так:

       List someList = new ArrayList(); someList.add("Apple"); someList.add("Ball"); for (String item : someList) { System.out.println(item); } // IS TRANSLATED TO: for(Iterator stringIterator = someList.iterator(); stringIterator.hasNext(); ) { String item = stringIterator.next(); System.out.println(item); } 
    2. Если выражение обязательно имеет тип массива T[] то:

       String[] someArray = new String[2]; someArray[0] = "Apple"; someArray[1] = "Ball"; for(String item2 : someArray) { System.out.println(item2); } // IS TRANSLATED TO: for (int i = 0; i < someArray.length; i++) { String item2 = someArray[i]; System.out.println(item2); } 

    Java 8 представила streamи, которые лучше всего работают. Мы можем использовать их как:

     someList.stream().forEach(System.out::println); Arrays.stream(someArray).forEach(System.out::println); 
     for (Iterator itr = someList.iterator(); itr.hasNext(); ) { String item = itr.next(); System.out.println(item); } 

    Вот эквивалентное выражение.

     for(Iterator sit = someList.iterator(); sit.hasNext(); ) { System.out.println(sit.next()); } 

    Также обратите внимание, что использование метода «foreach» в исходном вопросе имеет некоторые ограничения, например, невозможность удалить элементы из списка во время итерации.

    Новый for-loop легче читать и устраняет необходимость в отдельном iteratorе, но он действительно полезен только для проходов итерации только для чтения.

    Это добавляет красоту вашему коду, удаляя все основные петлевые помехи. Это дает чистый взгляд на ваш код, оправданный ниже.

    Нормальный for цикла:

     void cancelAll(Collection list) { for (Iterator i = list.iterator(); i.hasNext();) i.next().cancel(); } 

    Использование для каждого:

     void cancelAll(Collection list) { for (TimerTask t : list) t.cancel(); } 

    for-each – это конструкция над сборкой, которая реализует Iterator . Помните, что ваша коллекция должна реализовывать Iterator ; иначе вы не сможете использовать его для каждого.

    Следующая строка считывается как « для каждого списка TimerTask t в списке ».

     for (TimerTask t : list) 

    В случае for-each меньше шансов на ошибки. Вам не нужно беспокоиться об инициализации iteratorа или инициализации счетчика циклов и его завершении (где есть область ошибок).

    Альтернатива forEach, чтобы избежать «для каждого»:

     List someList = new ArrayList(); 

    Вариант 1 (обычный):

     someList.stream().forEach(listItem -> { System.out.println(listItem); }); 

    Вариант 2 (параллельное выполнение (быстрее)):

     someList.parallelStream().forEach(listItem -> { System.out.println(listItem); }); 

    Это будет выглядеть примерно так. Очень круто.

     for (Iterator i = someList.iterator(); i.hasNext(); ) System.out.println(i.next()); 

    Существует хорошая запись для каждого в документации Sun.

    Перед Java 8 вам необходимо использовать следующее:

     Iterator iterator = someList.iterator(); while (iterator.hasNext()) { String item = iterator.next(); System.out.println(item); } 

    Однако с введением Streams в Java 8 вы можете сделать то же самое в гораздо меньшем синтаксисе. Например, для вашего someList вы можете:

     someList.stream().forEach(System.out::println); 

    Здесь вы можете найти больше о streamах.

    Как было сказано многими хорошими ответами, объект должен реализовать Iterable interface если он хочет использовать цикл for-each .

    Я опубликую простой пример и попытаюсь объяснить по-другому, как работает for-each цикл.

    Пример for-each цикла:

     public class ForEachTest { public static void main(String[] args) { List list = new ArrayList(); list.add("111"); list.add("222"); for (String str : list) { System.out.println(str); } } } 

    Затем, если мы используем javap для декомпиляции этого classа, мы получим этот пример байт-кода:

     public static void main(java.lang.String[]); flags: ACC_PUBLIC, ACC_STATIC Code: stack=2, locals=4, args_size=1 0: new #16 // class java/util/ArrayList 3: dup 4: invokespecial #18 // Method java/util/ArrayList."":()V 7: astore_1 8: aload_1 9: ldc #19 // String 111 11: invokeinterface #21, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z 16: pop 17: aload_1 18: ldc #27 // String 222 20: invokeinterface #21, 2 // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z 25: pop 26: aload_1 27: invokeinterface #29, 1 // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator; 

    Как видно из последней строки образца, компилятор автоматически преобразует использование ключевого слова for-each в использование Iterator во время компиляции. Это может объяснить, почему объект, который не реализует Iterable interface , генерирует Exception при попытке использовать цикл for-each .

    Используя более старые версии Java, включая Java 7 вы можете использовать цикл foreach следующим образом.

     List items = new ArrayList<>(); items.add("A"); items.add("B"); items.add("C"); items.add("D"); items.add("E"); for(String item : items){ System.out.println(item); } 

    Ниже приведен самый последний способ использования цикла foreach в Java 8

    (цикл List с forEach + lambda выражение или ссылка на метод)

     //lambda //Output : A,B,C,D,E items.forEach(item->System.out.println(item)); //method reference //Output : A,B,C,D,E items.forEach(System.out::println); 

    Для получения дополнительной информации обратитесь к этой ссылке.

    https://www.mkyong.com/java8/java-8-foreach-examples/

     public static Boolean Add_Tag(int totalsize) { List fullst = new ArrayList(); for(int k=0;k 

    Java for-each idiom может применяться только к массивам или объектам типа * Iterable . Эта идиома подразумевается, поскольку она действительно поддерживается Итератором. Итератор запрограммирован программистом и часто использует целочисленный индекс или узел (в зависимости от структуры данных), чтобы отслеживать его положение. На бумаге он медленнее, чем обычный цикл for, в меньшей степени для «линейных» структур, таких как массивы и списки, но обеспечивает большую абстракцию.

    Java для каждого цикла (также известный как loop) является упрощенной версией цикла for. Преимущество состоит в том, что для записи меньше кода и меньше переменных для управления. Недостатком является то, что вы не контролируете значение шага и не имеете доступа к индексу цикла внутри тела цикла.

    Они лучше всего использовать, когда значение шага является простым шагом в 1, и когда вам нужен только доступ к текущему элементу цикла. Например, если вам нужно циклически перебирать каждый элемент в массиве или коллекции, не заглядывая вперед или за текущий элемент.

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

    Улучшенные для циклов следуют этому порядку выполнения:

    1) тело петли

    2) повторите с шага 1 до тех пор, пока весь массив или коллекция не пройден

    Пример. Целочисленный массив.

     int [] intArray = {1, 3, 5, 7, 9}; for(int currentValue : intArray) { System.out.println(currentValue); } 

    В переменной currentValue текущее значение зацикливается в массиве intArray. Обратите внимание, что нет явного значения шага – он всегда увеличивается на 1.

    Двоеточие можно считать означающим «in». Таким образом, расширенное выражение для цикла объявляет: loop over intArray и сохраняет текущее значение int массива в переменной currentValue.

    Вывод:

     1 3 5 7 9 

    Пример – String Array

    Мы можем использовать цикл for-each для итерации по массиву строк. Объявление цикла утверждает: loop over myStrings Строковый массив и сохраняет текущее значение String в переменной currentString.

     String [] myStrings = { "alpha", "beta", "gamma", "delta" }; for(String currentString : myStrings) { System.out.println(currentString); } 

    Вывод:

     alpha beta gamma delta 

    Пример – список

    Улучшенный цикл for также можно использовать для перебора над java.util.List следующим образом:

     List myList = new ArrayList(); myList.add("alpha"); myList.add("beta"); myList.add("gamma"); myList.add("delta"); for(String currentItem : myList) { System.out.println(currentItem); } 

    Объявление цикла объявляет: loop over myList List of Strings и сохраняет текущее значение List в переменной currentItem.

    Вывод:

     alpha beta gamma delta 

    Пример – набор

    Улучшенный цикл for также может использоваться для итерации по java.util.Set следующим образом:

     Set mySet = new HashSet(); mySet.add("alpha"); mySet.add("alpha"); mySet.add("beta"); mySet.add("gamma"); mySet.add("gamma"); mySet.add("delta"); for(String currentItem : mySet) { System.out.println(currentItem); } 

    Объявление цикла объявляет: loop over mySet Set Strings и сохраняет текущее значение Set в переменной currentItem. Обратите внимание: поскольку это Set, дублирующиеся значения String не сохраняются.

    Вывод:

     alpha delta beta gamma 

    Источник: Loops in Java – Ultimate Guide

    Это выглядит сумасшедшим, но эй это работает

     List someList = new ArrayList<>(); //has content someList.forEach(System.out::println); 

    Это работает. магия

    В Java 8 они вводили forEach. Используя этот список, Карты могут быть закодированы.

    Прокрутите список, используя для каждого

     List someList = new ArrayList(); someList.add("A"); someList.add("B"); someList.add("C"); someList.forEach(listItem -> System.out.println(listItem)) 

    или

     someList.forEach(listItem-> { System.out.println(listItem); }); 

    Скопируйте карту, используя для каждого

     Map mapList = new HashMap<>(); mapList.put("Key1", "Value1"); mapList.put("Key2", "Value2"); mapList.put("Key3", "Value3"); mapList.forEach((key,value)->System.out.println("Key: " + key + " Value : " + value)); 

    или

     mapList.forEach((key,value)->{ System.out.println("Key : " + key + " Value : " + value); }); 
     List Items = obj.getItems(); for(Item item:Items) { System.out.println(item); } 

    Итерации по всем объектам в таблице Items.

    Interesting Posts
    Давайте будем гением компьютера.