Что делают две точки в java? [Дубликат]

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

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

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

(loop a List with 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/

public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
            for(int k=0;k<totalsize;k++)
            {
              fullst.addAll();
            }
}

Java для каждого цикла (ака расширенный для цикла) является упрощенной версией цикла 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<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

Источник: Петли в Java - Руководство по Ultimate

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

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

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

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

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

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

Выход

First
Second
Third

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

Это выглядит безумно, но hey it works

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

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

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

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

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

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

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

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

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