Как работает Java для каждого цикла? - PullRequest
Новая
       76

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

1384 голосов
/ 17 сентября 2008

Рассмотрим: 

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

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

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

Ответы [ 26 ]

1096 голосов
/ 17 сентября 2008 
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 .

467 голосов
/ 17 сентября 2008

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

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. Даже ваши собственные типы, следовательно, может использоваться с этим синтаксис.

141 голосов
/ 01 марта 2014

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

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

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

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

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

Индексы на 23- 40 процентов быстрее, чем итераторы при доступе к массивам int или Integer. Вот выходные данные класса тестирования в нижней части этого поста, в котором суммируются числа в массиве primitive-int из 100 элементов (A - итератор, B - индекс): 

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)

Я также выполнил это для массива Integer, и индексы по-прежнему явный победитель, но только на 18-25% быстрее.

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

Для List из Integers, однако, итераторы - явный победитель. Просто измените массив int в классе теста на: 

List<Integer> intList = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100});

И внести необходимые изменения в тест-функцию (от int[] до List<Integer>, length до size() и т. Д.): 

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,429,929,976 nanoseconds
Test B: 5,262,782,488 nanoseconds
A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,907,391,427 nanoseconds
Test B: 3,957,718,459 nanoseconds
A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,566,004,688 nanoseconds
Test B: 4,221,746,521 nanoseconds
A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,770,945,276 nanoseconds
Test B: 3,829,077,158 nanoseconds
A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,467,474,055 nanoseconds
Test B: 5,183,149,104 nanoseconds
A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,439,983,933 nanoseconds
Test B: 3,509,530,312 nanoseconds
A faster by 69,546,379 nanoseconds (1.4816434912159906% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,451,101,466 nanoseconds
Test B: 5,057,979,210 nanoseconds
A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)

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

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

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

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

Я создал этот класс «сравнивать время, которое нужно делать с любыми двумя вещами» после прочтения этого вопроса в переполнении стека: 

import  java.text.NumberFormat;
import  java.util.Locale;

/**
   &lt;P&gt;{@code java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt;

   @see  &lt;CODE&gt;&lt;A HREF=&quot;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;https://stackoverflow.com/questions/180158/how-do-i-time-a-methods-execution-in-java&lt;/A&gt;&lt;/CODE&gt;
 **/
public class TimeIteratorVsIndexIntArray {

    public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);

    public static final void main(String[] tryCount_inParamIdx0) {
        int testCount;

        // Get try-count from a command-line parameter
        try {
           testCount = Integer.parseInt(tryCount_inParamIdx0[0]);
        }
        catch(ArrayIndexOutOfBoundsException | NumberFormatException x) {
           throw  new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x);
        }

        //Test proper...START
        int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100};

        long lStart = System.nanoTime();
        for(int i = 0; i < testCount; i++) {
           testIterator(intArray);
        }

        long lADuration = outputGetNanoDuration("A", lStart);

        lStart = System.nanoTime();
        for(int i = 0; i < testCount; i++) {
           testFor(intArray);
        }

        long lBDuration = outputGetNanoDuration("B", lStart);

        outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B");
    }

    private static final void testIterator(int[] int_array) {
       int total = 0;
       for(int i = 0; i < int_array.length; i++) {
          total += int_array[i];
       }
    }

    private static final void testFor(int[] int_array) {
       int total = 0;
       for(int i : int_array) {
          total += i;
       }
    }
    //Test proper...END

    //Timer testing utilities...START
    public static final long outputGetNanoDuration(String s_testName, long l_nanoStart) {
        long lDuration = System.nanoTime() - l_nanoStart;
        System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds");
        return  lDuration;
    }

    public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName) {
        long lDiff = -1;
        double dPct = -1.0;
        String sFaster = null;
        if(l_aDuration > l_bDuration) {
            lDiff = l_aDuration - l_bDuration;
            dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5);
            sFaster = "B";
        }
        else {
            lDiff = l_bDuration - l_aDuration;
            dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5);
            sFaster = "A";
        }
        System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)");
        return  lDiff;
   }

   //Timer testing utilities...END

}
125 голосов
/ 31 октября 2011

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

36 голосов
/ 17 сентября 2008

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

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

while (iterator.hasNext()) {
  String item = iterator.next();
  System.out.println(item);
}
23 голосов
/ 19 апреля 2014

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

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

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

выход 

First
Second
Third
22 голосов
/ 17 сентября 2008

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

21 голосов
/ 07 ноября 2013

Синтаксис цикла 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
21 голосов
/ 20 октября 2015

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

  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);
20 голосов
/ 17 сентября 2008

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

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

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

Страница:
...