Вопрос:

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

java foreach syntactic-sugar

2472682 просмотра

26 ответа

15025 Репутация автора

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

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

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

Автор: Jay R. Источник Размещён: 17.09.2008 04:44

Ответы (26)


1111 плюса

13905 Репутация автора

Решение
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 .

Автор: nsayer Размещён: 17.09.2008 04:46

37 плюса

3662 Репутация автора

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

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

while (iterator.hasNext()) {
  String item = iterator.next();
  System.out.println(item);
}
Автор: toluju Размещён: 17.09.2008 04:46

9 плюса

1907 Репутация автора

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

for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) {
    System.out.println(sit.next());
}
Автор: Hank Размещён: 17.09.2008 04:48

6 плюса

1350 Репутация автора

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

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

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

Автор: Pete Размещён: 17.09.2008 04:48

11 плюса

0 Репутация автора

for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) {
   String item = itr.next();
   System.out.println(item);
}
Автор: Размещён: 17.09.2008 04:49

23 плюса

54775 Репутация автора

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

Автор: EfForEffort Размещён: 17.09.2008 04:50

9 плюса

12815 Репутация автора

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

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

Автор: billjamesdev Размещён: 17.09.2008 04:53

471 плюса

14754 Репутация автора

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

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

Автор: Mikezx6r Размещён: 17.09.2008 05:06

20 плюса

5055 Репутация автора

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

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

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

Автор: Ryan Delucchi Размещён: 17.09.2008 06:04

126 плюса

29955 Репутация автора

Вот ответ, который не предполагает знания Java Iterators. Это менее точно, но это полезно для образования.

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

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.

Автор: MRocklin Размещён: 31.10.2011 04:35

15 плюса

265 Репутация автора

Концепция цикла 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.

Автор: oneConsciousness Размещён: 04.10.2012 07:47

22 плюса

323 Репутация автора

Синтаксис цикла 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
Автор: PrivateName Размещён: 07.11.2013 05:35

143 плюса

14270 Репутация автора

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

для каждого

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

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

И внесите необходимые изменения в функцию test ( int[]to List<Integer>, lengthto 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

}
Автор: aliteralmind Размещён: 01.03.2014 12:47

23 плюса

287 Репутация автора

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

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

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

Выход

First
Second
Third
Автор: Jrovalle Размещён: 19.04.2014 03:22

2 плюса

218 Репутация автора

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

Автор: WIll Размещён: 08.06.2015 01:28

7 плюса

498 Репутация автора

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

Нормальный 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 является конструкцией над коллекцией, которая реализует Iterator . Помните, что ваша коллекция должна реализовывать Iterator ; в противном случае вы не можете использовать его для каждого.

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

for (TimerTask t : list)

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

Автор: Manohar Размещён: 30.09.2015 04:44

21 плюса

13889 Репутация автора

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

  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);
Автор: i_am_zero Размещён: 20.10.2015 09:12

3 плюса

91 Репутация автора

public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
            for(int k=0;k<totalsize;k++)
            {
              fullst.addAll();
            }
}
Автор: Santhosh Rajkumar Размещён: 27.10.2016 11:31

5 плюса

105 Репутация автора

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

Автор: L Joey Размещён: 29.11.2016 03:20

8 плюса

1221 Репутация автора

Альтернатива 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);
});
Автор: Alexander Drobyshevsky Размещён: 17.05.2017 07:14

1 плюс

119 Репутация автора

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

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

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

Автор: Rei Brown Размещён: 29.01.2018 08:38

6 плюса

745 Репутация автора

До 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);

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

Автор: stackFan Размещён: 27.02.2018 06:11

-1 плюса

217 Репутация автора

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

Перебирает все объекты в таблице Items.

Автор: shubhranshu Размещён: 27.03.2018 08:15

3 плюса

1019 Репутация автора

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

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

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

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

1) тело петли

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

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

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

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

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

Выход:

1
3
5
7
9

Пример - String Array

Мы можем использовать цикл for-each для итерации по массиву строк. Объявление цикла гласит: зациклите массив String 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);
}

Объявление цикла сообщает: переберите список строк myList и сохраните текущее значение списка в переменной 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);
}

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

Выход:

alpha
delta
beta
gamma

Источник: циклы в Java - полное руководство

Автор: gomisha Размещён: 02.05.2018 01:11

9 плюса

5010 Репутация автора

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

Автор: Dulith De Costa Размещён: 21.06.2018 11:05

7 плюса

511 Репутация автора

В 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);
});
Автор: vivekkurien Размещён: 30.08.2018 01:23
Вопросы из категории :
32x32