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

https://stackoverflow.com/questions/85190

01-07-2019
|

Вопрос

Рассмотреть:

List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList

for (String item : someList) {
    System.out.println(item);
}

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

Решение

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.

Другие советы

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

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.
}

Итак, общее резюме:
[говорящий] Ниже приведена более подробная форма того, что происходит:

for(Iterator<String> i = someList.iterator(); i.hasNext(); ) {
  String item = i.next();
  System.out.println(item);
}
Обратите внимание, что если вам нужно использовать i.remove();в вашем цикле или получите доступ к фактическому итератору каким-либо образом, вы не можете использовать for( :) идиома, поскольку фактический итератор просто выведен.

[Denis Bueno]

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

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

предначертание

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 напрямую.Например, попытка удалить элемент при использовании foreach может (будет?) привести к ConcurrentModificationException.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;https://stackoverflow.com/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

}

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

Цикл for-each в Java использует базовый механизм итератора.Таким образом, это идентично следующему:

Iterator<String> iterator = someList.iterator();

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

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

List<String> messages = Arrays.asList("First", "Second", "Third");

void forTest(){
    messages.forEach(System.out::println);
}

Выходной сигнал

First
Second
Third

Это подразумевается в ответе nsayer, но стоит отметить, что синтаксис OP for (..) будет работать, когда "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 зацикливайтесь на этом.

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

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

Если вы хотите отредактировать элементы, используйте оригинал 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

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

Если тип выражения является подтипом Iterable тогда перевод будет выглядеть следующим образом:

List<String> someList = new ArrayList<String>();
someList.add("Apple");
someList.add("Ball");
for (String item : someList) {
    System.out.println(item);
}

// IS TRANSLATED TO:

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

Если выражение обязательно имеет тип массива 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 представила потоки, которые в целом работают лучше.Мы можем использовать их как:

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

Конструкция цикла Java "для каждого" позволит выполнять итерации по двум типам объектов:

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

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

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

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

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

// In this loop it is assumed that the list starts with index 0
for(int i=0; i<list.length; i++){

}

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

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

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

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

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

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

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

List<String> 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

(зациклите список с помощью forEach + ссылка на лямбда-выражение или метод)

//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/

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

List<String> someList = new ArrayList<String>();

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

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

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

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

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

Нормальный for петля:

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

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

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

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

Следующая строка читается как "для каждой временной задачи t в списке."

for (TimerTask t : list)

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

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

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

List<String> someList = new ArrayList<String>();
someList.add("A");
someList.add("B");
someList.add("C");

someList.forEach(listItem -> System.out.println(listItem))

или

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

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

Map<String, String> 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);
});

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

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

Есть хорошая статья о для каждого в Документация Sun.

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

Iterator<String> iterator = someList.iterator();

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

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

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

Вы можете узнать больше о потоках здесь.

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

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

Тот Самый for-each пример цикла:

public class ForEachTest {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("222");

        for (String str : list) {
            System.out.println(str);
        }
    }
}

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

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."<init>":()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 во время компиляции.Это может объяснить, почему object, который не реализует Iterable interface, выбросит Exception когда он пытается использовать for-each петля.

public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
            for(int k=0;k<totalsize;k++)
            {
              fullst.addAll();
            }
}

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

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

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

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

1) корпус петли

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

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

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

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

Можно подумать, что двоеточие означает “в”.Итак, расширенное объявление цикла for гласит:выполните цикл над intArray и сохраните текущее значение массива int в переменная currentValue.

Выходной сигнал:

Пример – Массив строк

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

String [] myStrings  = {
  "alpha",
  "beta",
  "gamma",
  "delta"
};

for(String currentString : myStrings) {
  System.out.println(currentString);
}

Выходной сигнал:

alpha
beta
gamma
delta

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

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

List<String> myList = new ArrayList<String>();
myList.add("alpha");
myList.add("beta");
myList.add("gamma");
myList.add("delta");

for(String currentItem : myList) {
  System.out.println(currentItem);
}

В объявлении цикла указано:выполните цикл по списку строк myList и сохраните текущее значение списка в переменная CurrentItem.

Выходной сигнал:

alpha
beta
gamma
delta

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

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

Set<String> mySet = new HashSet<String>();
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);
}

В объявлении цикла указано:выполните цикл по набору строк mySet и сохраните текущее установленное значение в переменная CurrentItem.Обратите внимание, что, поскольку это набор, повторяющиеся строковые значения не сохраняются.

Выходной сигнал:

alpha
delta
beta
gamma

Источник: Циклы в Java - Окончательное руководство

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

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

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

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

List<Item> Items = obj.getItems();
for(Item item:Items)
             {
                System.out.println(item); 
             }

Выполняет итерацию по всем объектам в таблице Items.

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow

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

предначертание

Итератор

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

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

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

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

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

Выходной сигнал

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

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