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



13 Answers

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

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 (:) idiom, так как фактический Iterator просто выведен.

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

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

java цикл for each

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

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

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




Вот ответ, который не предполагает знания итераторов 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 8 вы можете использовать это:

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

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

Выход

First
Second
Third



Синтаксис цикла 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 (double b:s) // Invalid-double is not String

Если вы хотите редактировать элементы, используйте for цикл 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



Как определено в 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);



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



Также обратите внимание, что использование метода «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();
}

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

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

for (TimerTask t : list)

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




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

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 .




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




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

Итерации по всем объектам в таблице Items.






Related