Как работает 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);
}

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

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

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

Цикл foreach, добавленный в Java 5 (также называемый "расширенный для цикла"), эквивалентен использованию синтаксического сахара java.util.Iterator --it для одного и того же. Поэтому при чтении каждого элемента по одному и по порядку всегда следует выбирать 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 vs. for: Основные различия

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

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 доступа for массиву loop. Однако при доступе к массивам - по крайней мере с примитивными и оберточными массивами - доступ через индексы значительно быстрее.

Сроки разницы между итератором и доступом к индексу для примитивных 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-array в тестовом классе на:

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() и т.д.):

[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)

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

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

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

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

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

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

Я создал этот класс 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="/questions/10131/how-do-i-time-a-methods-execution-in-java">/questions/10131/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. Он менее точен, но он полезен для образования.

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

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 используется базовый механизм итератора. Поэтому он идентичен следующему:

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

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

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

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

Как определено в JLS для каждого цикла может быть две формы:

• Если тип выражения является подтипом 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);

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

Однако, в отличие от других для контурных конструкций, foreach loop обычно не поддерживайте явный счетчик: они по сути говорят: "Сделайте это все в этом наборе", а не "делать это 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-loop легче читать и устраняет необходимость в отдельном итераторе, но он действительно полезен только для итераций, доступных только для чтения.

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

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

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

for (TimerTask t : list)

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

Используя более старые версии 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

(цикл 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/

Перед 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);

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

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

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

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

Как и многие хорошие ответы, объект должен реализовать 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 для каждого цикла (также известный как 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<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);
}

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

Вывод:

alpha
beta
gamma
delta

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

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

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

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

Вывод:

alpha
delta
beta
gamma

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

Java for-each idiom может применяться только к массивам или объектам типа * Итерабельный. Эта идиома неявная, поскольку она действительно поддерживается Iterator. Итератор запрограммирован программистом и часто использует целочисленный индекс или node (в зависимости от структуры данных), чтобы отслеживать его положение. На бумаге он медленнее, чем обычный цикл 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.