Каковы преимущества Enhanced for loop и Iterator в Java?

Может кто-нибудь, пожалуйста, укажите мне, каковы преимущества Enhanced for loop и Iterators в java +5?

Ответ 1

Сильные стороны, а также слабости довольно хорошо обобщены в Stephen Colebourne (Joda-Time, JSR-310 и т.д.) Улучшено для каждого цикла итерации цикла предложение распространить его на Java 7:

РЕЗЮМЕ ФУНКЦИИ:

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

ОСНОВНОЕ ПРЕИМУЩЕСТВО

Цикл for-each - почти наверняка самый новый популярная функция от Java 5. Работает потому что он увеличивает абстракцию уровень - вместо того, чтобы выражать низкоуровневые сведения о том, как перемещаться вокруг списка или массива (с индексом или итератор), разработчик просто заявляет, что они хотят язык заботится обо всем остальном. Однако все выгоды теряются, поскольку как только разработчик должен получить доступ индекс или удалить элемент.

Оригинальная Java 5 для каждой работы относительно консервативная позиция на количество вопросов, направленных на 80%. Однако петли являются такими общей формы в кодировании, что оставшиеся 20%, которые не были решены представляет собой значительную часть кода.

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

ОСНОВНАЯ ПРЕИМУЩЕСТВА:

Общая идиома кодирования выражается в более высокая абстракция, чем в настоящее время. Это помогает читабельности и ясности.

...

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

См. также

Ответ 2

Для меня ясно, что основным преимуществом является читаемость.

for(Integer i : list){
   ....
}

явно лучше, чем что-то вроде

for(int i=0; i < list.size(); ++i){
  ....
}

Ответ 3

Я думаю, что это в значительной степени подвело страница документации, в которой она была представлена здесь.

Итерирование по коллекции является более уродливым, чем должно быть

Итак, истинно.

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

Точно

Когда вы видите двоеточие (:), прочитайте его как "in". Цикл выше читается как "для каждого TimerTask t в c". Как вы можете видеть, каждая конструкция прекрасно сочетается с дженериками. Он сохраняет всю безопасность типа, удаляя оставшийся беспорядок. Поскольку вам не нужно объявлять итератор, вам не нужно предоставлять ему общее объявление. (Компилятор делает это за вас за спиной, но вам не нужно беспокоиться об этом.)

Я хотел бы подвести итог, но я думаю, что эта страница делает это довольно хорошо.

Ответ 4

Вы можете перебирать любую коллекцию, которая является Iterable, а также массивом. И разница в производительности - это не то, о чем вам следует беспокоиться вообще.

Чтение важно.

Prefer this    
for (String s : listofStrings) 
    {
     ... 
    }

over

    for (Iterator<String> iter = listofStrings.iterator(); iter.hasNext(); )
    {
     String s = iter.next();
     ...
    }

Обратите внимание, что если вам нужно удалить элементы во время повтора, вам нужно использовать Iterator.

Например,

List<String> list = getMyListofStrings(); 

    for (Iterator<String> iter = list.iterator(); iter.hasNext(); ) 
    {
        String s = iter.next();
        if (someCondition) {
            iter.remove(); 
        }
    }

Вы не можете использовать for(String s : myList) для удаления элемента в списке.
Также обратите внимание, что при итерации по массиву foreach (или расширенный для) может использоваться только для получения элементов, вы не можете изменять элементы в массиве.
Для получения дополнительной информации см. this.

Ответ 5

Чистый синтаксис! Нет никакой разницы с перспективой производительности, поскольку это просто удобство для программиста.

Ответ 6

Как и другие, расширенный цикл for обеспечивает более чистый синтаксис, считываемый код и меньший тип.

Кроме того, он избегает возможного сценария ошибок с индексом из привязки. Например, когда вы перебираете список вручную, вы можете использовать индексную переменную неправильно, например:

for(int i=0; i<= list.size(); i++)

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

Ответ 7

Основной недостаток - это создание Iterator, которого нет в цикле индекса. Обычно это нормально, но в критически важных средах (например, в режиме реального времени, когда он должен запускаться несколько сотен раз в секунду), это может вызвать серьезное вмешательство в GC...

Ответ 8

Как уже говорят другие, это синтаксический сахар для чистых. Если вы сравните с циклом класса Iterator, вы найдете одну меньшую переменную, которую вам придется объявить.

Ответ 9

Это более красноречиво. Только проблема - это проверка нуля.

for (String str : strs) {  // make sure strs is not null here
    // Do whatever
}

Ответ 10

A foreach/усиленный для цикла /for служит для указания курсора на объект данных. Это особенно полезно, когда вы думаете, что "ходить по строке за строкой" или "вести запись набора результатов по записи", как это просто и просто реализовать.

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

Ответ 11

Меньше печатать! Плюс больше помощи от компилятора

Ответ 12

Усовершенствованный for-loop предлагает следующее основное преимущество:

for (int i=0; i <= list.size(); i++)

Это исключает повторный расчет list.size() на каждой итерации в не расширенной версии выше. Это преимущество производительности, которое имеет значение.

В качестве альтернативы вы можете рассчитать размер вне цикла следующим образом, используя дополнительную переменную:

int size = list.size();
for (int i=0; i <= size; i++)