Рассмотрим:
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(); в вашем цикле или каким-то образом получить доступ к фактическому итератору, вы не можете использовать idiom for ( : ), так как фактический итератор просто выводится.
Как отметил Денис Буено, этот код работает для любого объекта, который реализует Iterable interface.
Кроме того, если правая часть идиомы 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); }Обратите внимание, что если вам нужно использовать i.remove(); в вашем цикле или доступ фактический итератор каким-то образом, вы не может использовать for (:) идиому, поскольку фактический Итератор - это просто случайно.
Это подразумевается ответом nsayer, но стоит отметить, что ОП для (..) синтаксис будет работать, когда "someList" все, что реализует java.lang.Iterable - у него нет быть списком или какой-либо коллекцией из java.util. Даже ваши собственные типы, поэтому можно использовать с этим синтаксис.
Вот ответ, который не предполагает знания итераторов 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 над итератором, поскольку он более удобен и краток.
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. Однако при доступе к массивам - по крайней мере с примитивными и оберточными массивами - доступ через индексы значительно быстрее.
Индексы на 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)
В одном тесте они почти эквивалентны, но с коллекциями выигрывает итератор.
* Это сообщение основано на двух ответах, которые я написал в "Переполнение стека":
Дополнительная информация: что более эффективно, для каждого цикла или итератора?
Я создал этот класс 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 используется базовый механизм итератора. Поэтому он идентичен следующему:
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 легче читать и устраняет необходимость в отдельном итераторе, но он действительно полезен только для итераций, доступных только для чтения.
Это добавляет красоту вашему коду, удаляя все основные беспорядки цикла. Это дает чистый взгляд на ваш код, оправданный ниже.
Обычный цикл 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 вероятность ошибок меньше. Вам не нужно беспокоиться об инициализации итератора или инициализации счетчика циклов и его завершении (где есть область ошибок).
Альтернатива 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 (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);
Вы можете узнать больше о потоках здесь.
Используя более старые версии 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);
Для получения дополнительной информации обратитесь к этой ссылке.
Как и многие хорошие ответы, объект должен реализовать 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-each idiom может применяться только к массивам или объектам типа * Итерабельный. Эта идиома неявная, поскольку она действительно поддерживается Iterator. Итератор запрограммирован программистом и часто использует целочисленный индекс или node (в зависимости от структуры данных), чтобы отслеживать его положение. На бумаге он медленнее, чем обычный цикл 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<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
Это выглядит сумасшедшим, но он работает
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.