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

считаем:

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

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

26 ответов


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

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

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

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

[Denis Bueno]

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


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


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

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

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

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

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

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

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

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

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

[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 выигрывает.

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

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

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

я создал этот класс compare-the-time-it-takes-to-do-any-two-things после чтения этот вопрос при переполнении стека:

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

}

цикл 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 для(..) синтаксис будет работать, когда "someList"ничего это реализует java.ленг.Iterable -- это не должен быть список или какая-то коллекция из java.утиль. Поэтому даже ваши собственные типы могут использоваться с этим синтаксисом.


синтаксис цикла 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

конструкция цикла Java "for-each" позволит выполнять итерацию по двум типам объектов:

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

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


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

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

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

концепция цикла foreach, как указано в Википедии, это показано ниже:

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

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

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

}

но предположим, что если список начинается с индекса 1, то этот цикл будет вызывать исключение, поскольку он не найдет элемента в индексе 0, и эта ошибка называется ошибкой off-by-one. Поэтому, чтобы избежать этого off-by-one ошибка используется концепция цикла 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-loop легче читать и устраняет необходимость в отдельном итераторе, но используется только для итераций только для чтения.


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

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

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

использование для-each:

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

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

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

for (TimerTask t : list)

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


альтернатива 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);
});

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

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);
}

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

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

вы можете найти больше о потоках здесь.


использование более старых версий 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/


как сказали многие хорошие ответы, объект должен реализовать 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 во время компиляции. Это может объяснить, почему объект, который не реализует Iterable interface, скинете Exception, когда он пытается использовать 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);
});

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

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


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

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

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

Enhanced для циклов следуйте этому порядку выполнения:

1) тело цикла

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

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

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

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

можно подумать, что двоеточие означает "в". Таким образом, расширенное объявление цикла для состояний: цикл над intArray и сохранить текущее значение массива int на текущий значение переменная.

выход:

1
3
5
7
9

Example - String Array

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

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

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

выход:

alpha
beta
gamma
delta

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

увеличенный для петли можно также использовать к повторите над java.утиль.Список выглядит следующим образом:

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

Пример-Set

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

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-Ultimate Guide


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

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.