Java 8 Iterable.forEach () vs foreach loop

Преимущество возникает, когда операции могут выполняться параллельно. (См. http://java.dzone.com/articles/devoxx-2012-java-8-lambda-and – раздел о внутренней и внешней итерации)

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

• Если вы хотите, чтобы ваш цикл выполнялся параллельно, вы могли просто написать

    joins.parallelStream().forEach(join -> mIrc.join(mSession, join)); 

  Вам нужно будет написать дополнительный код для обработки streamов и т. Д.

Примечание. Для моего ответа я предположил, что присоединяется к интерфейсу java.util.Stream . Если join реализует только интерфейс java.util.Iterable это уже не так.

Лучшая практика – использовать for-each . Помимо нарушения принципа Keep It Simple, Stupid , новый метод forEach() имеет по крайней мере следующие недостатки:

• Невозможно использовать не конечные переменные . Таким образом, код, подобный приведенному ниже, не может быть превращен в forIach lambda:

   Object prev = null; for(Object curr : list) { if( prev != null ) foo(prev, curr); prev = curr; } 

• Не удается обработать проверенные исключения . Lambdas на самом деле запрещено запрещать проверенные исключения, но обычные функциональные интерфейсы, такие как Consumer , не объявляют. Поэтому любой код, который выдает проверенные исключения, должен обернуть их в try-catch или Throwables.propagate() . Но даже если вы это сделаете, не всегда ясно, что происходит с выброшенным исключением. Его можно было проглотить где-то в кишках forEach()

• Ограниченный контроль streamа . return в lambda равен continue в каждом для каждого, но нет эквивалента break . Также трудно делать такие вещи, как возвращаемые значения, короткое замыкание или установить флаги (что немного облегчило бы ситуацию, если бы это не было нарушением правила не конечных переменных ). «Это не просто оптимизация, но и критическая, когда вы считаете, что некоторые последовательности (например, чтение строк в файле) могут иметь побочные эффекты, или вы можете иметь бесконечную последовательность».

• Может выполняться параллельно , что является ужасным, ужасным для всех, кроме 0.1% вашего кода, который нужно оптимизировать. Любой параллельный код необходимо продумать (даже если он не использует блокировки, летучие компоненты и другие особенно неприятные аспекты традиционного многопоточного исполнения). Любая ошибка будет трудно найти.

• Это может повредить производительность , потому что JIT не может оптимизировать forEach () + lambda в той же степени, что и обычные петли, особенно теперь, когда лямбды новы. Под «оптимизацией» я не имею в виду накладные расходы на вызов lambdas (что мало), но на сложный анализ и преобразование, которые выполняет современный JIT-компилятор при запуске кода.

• Если вам нужен параллелизм, вероятно, гораздо быстрее и не намного сложнее использовать ExecutorService . Потоки являются как автоматическими (читайте: не знаете много о вашей проблеме), и используйте специализированную страtagsю распараллеливания (чтение: неэффективность для общего случая) ( рекурсивное разложение fork-join ).

• Делает отладку более запутанной из-за иерархии вложенных вызовов и, бог, запрещает параллельное выполнение. Отладчик может иметь проблемы с отображением переменных из окружающего кода, и такие вещи, как пошаговое выполнение, могут работать не так, как ожидалось.

• Потокам в целом сложнее кодировать, читать и отлаживать . На самом деле это относится к сложным « беглым » API в целом. Комбинация сложных одиночных утверждений, интенсивное использование дженериков и отсутствие промежуточных переменных заставляют создавать путаные сообщения об ошибках и отлаживать отладку. Вместо того, чтобы «этот метод не имеет перегрузки для типа X», вы получаете сообщение об ошибке ближе к «где-то вы испортили типы, но мы не знаем, где и как». Точно так же вы не можете проходить и анализировать вещи в отладчике так же легко, как когда код разбит на несколько операторов, а промежуточные значения сохраняются в переменных. Наконец, чтение кода и понимание типов и поведения на каждом этапе исполнения могут быть нетривиальными.

• Выливается как больной палец . Язык Java уже имеет оператор for-each. Зачем заменить его вызовом функции? Зачем поощрять скрывать побочные эффекты где-то в выражениях? Зачем поощрять громоздкие однострочники? Смешение регулярных для каждого и нового forEach волей-неволей – плохой стиль. Кодекс должен говорить в идиомах (шаблоны, которые быстро осмысливаются из-за их повторения), и чем меньше идиом используется, тем понятнее код и меньше времени тратится на решение, какую идиому использовать (большой тайм-стоп для таких перфекционистов, как я! ).

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

Особенно оскорбительным для меня является тот факт, что Stream не реализует Iterable (несмотря на то, что на самом деле имеет iterator метода) и не может использоваться в for-each, только с forEach (). Я рекомендую передавать streamи в Iterables с помощью (Iterable)stream::iterator . Лучшей альтернативой является использование StreamEx, который исправляет ряд проблем Stream API, включая реализацию Iterable .

Тем не менее, forEach() полезен для следующего:

• Атомно итерация по синхронизированному списку . До этого список, сгенерированный с помощью Collections.synchronizedList() был атомарным в отношении таких вещей, как get или set, но не был поточно-безопасным при повторе.

• Параллельное выполнение (с использованием соответствующего параллельного streamа) . Это избавит вас от нескольких строк кода и использования ExecutorService, если ваша проблема соответствует предположениям производительности, встроенным в streamи и разделители.

• Конкретные контейнеры, которые , подобно синхронизированному списку, выигрывают от контроля за итерацией (хотя это в значительной степени теоретическое, если только люди не могут привести больше примеров)

• Вызов одной функции более чисто с помощью forEach() и аргумента ссылки метода (т. list.forEach (obj::someMethod) ). Однако имейте в виду пункты проверенных исключений, более сложную отладку и уменьшайте количество идиом, которые вы используете при написании кода.

Статьи, которые я использовал для справки:

• Все о Java 8
• Итерация внутри и снаружи (как указывает другой плакат)

РЕДАКТИРОВАТЬ: Похоже, что некоторые из первоначальных предложений для lambda (например, http://www.javac.info/closures-v06a.html ) решили некоторые из затронутых мной проблем (при этом, конечно, добавление их собственных осложнений).

При чтении этого вопроса можно получить впечатление, что Iterable#forEach в сочетании с lambda-выражениями является ярлыком / заменой для записи традиционного для каждого цикла. Это просто неправда. Этот код из OP:

 joins.forEach(join -> mIrc.join(mSession, join)); 

не является ярлыком для написания

 for (String join : joins) { mIrc.join(mSession, join); } 

и, безусловно, не следует использовать таким образом. Вместо этого он предназначен как ярлык (хотя это не совсем то же самое) для написания

 joins.forEach(new Consumer() { @Override public void accept(T join) { mIrc.join(mSession, join); } }); 

И это заменяет следующий код Java 7:

 final Consumer c = new Consumer() { @Override public void accept(T join) { mIrc.join(mSession, join); } }; for (T t : joins) { c.accept(t); } 

Замена тела цикла функциональным интерфейсом, как в приведенных выше примерах, делает ваш код более явным: вы говорите, что (1) тело цикла не влияет на окружающий код и stream управления, и (2) тело цикла может быть заменено другой реализацией функции, не затрагивая окружающий код. Невозможность доступа к не конечным переменным внешней области не является дефицитом функций / lambdas, это функция, которая отличает семантику Iterable#forEach от семантики традиционного для каждого цикла. Как только вы привыкнете к синтаксису Iterable#forEach , он делает код более читаемым, потому что вы сразу получаете эту дополнительную информацию о коде.

Традиционные для каждой петли, безусловно, останутся хорошей практикой (чтобы избежать злоупотребления термином « лучшая практика ») на Java. Но это не означает, что Iterable#forEach следует считать плохой практикой или плохим стилем. Всегда хорошая практика – использовать правильный инструмент для выполнения этой работы, и это включает в себя смешивание традиционных для каждого цикла с Iterable#forEach , где это имеет смысл.

Поскольку недостатки Iterable#forEach уже обсуждались в этом streamе, вот несколько причин, почему вы, вероятно, захотите использовать Iterable#forEach :

• Чтобы сделать ваш код более явным: как описано выше, Iterable#forEach может сделать ваш код более явным и читаемым в некоторых ситуациях.

• Чтобы сделать ваш код более расширяемым и поддерживаемым: использование функции как тела цикла позволяет заменить эту функцию различными реализациями (см. Шаблон страtagsи ). Например, вы можете легко заменить выражение lambda вызовом метода, который может быть перезаписан подclassами:

   joins.forEach(getJoinStrategy()); 

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

• Чтобы сделать ваш код более отлажимым : отключение реализации цикла из декларации также облегчает отладку, поскольку вы можете иметь специальную реализацию отладки, которая выводит отладочные сообщения без необходимости загромождать ваш основной код с помощью if(DEBUG)System.out.println() . Реализация отладки может быть, например, делегатом , который украшает реализацию фактической функции.

• Чтобы оптимизировать критически важный для производительности код: В отличие от некоторых утверждений в этом streamе, Iterable#forEach уже обеспечивает лучшую производительность, чем традиционный для каждого цикла, по крайней мере, при использовании ArrayList и запуска Hotspot в режиме «-клиент». Хотя это увеличение производительности мало и незначительно для большинства случаев использования, бывают ситуации, когда эта дополнительная производительность может иметь значение. Например, разработчики библиотек обязательно захотят оценить, если некоторые из существующих реализаций цикла должны быть заменены на Iterable#forEach .

  Чтобы подтвердить это утверждение фактами, я сделал несколько микро-тестов с помощью Caliper . Вот тестовый код (требуется последний калибр от git):

   @VmOptions("-server") public class Java8IterationBenchmarks { public static class TestObject { public int result; } public @Param({"100", "10000"}) int elementCount; ArrayList list; TestObject[] array; @BeforeExperiment public void setup(){ list = new ArrayList<>(elementCount); for (int i = 0; i < elementCount; i++) { list.add(new TestObject()); } array = list.toArray(new TestObject[list.size()]); } @Benchmark public void timeTraditionalForEach(int reps){ for (int i = 0; i < reps; i++) { for (TestObject t : list) { t.result++; } } return; } @Benchmark public void timeForEachAnonymousClass(int reps){ for (int i = 0; i < reps; i++) { list.forEach(new Consumer() { @Override public void accept(TestObject t) { t.result++; } }); } return; } @Benchmark public void timeForEachLambda(int reps){ for (int i = 0; i < reps; i++) { list.forEach(t -> t.result++); } return; } @Benchmark public void timeForEachOverArray(int reps){ for (int i = 0; i < reps; i++) { for (TestObject t : array) { t.result++; } } } } 

  И вот результаты:

  • Результаты для -клиента
  • Результаты для -server

  При работе с «-client» Iterable#forEach превосходит традиционный цикл for через ArrayList, но все еще медленнее, чем прямое повторение массива. При работе с «-сервером» производительность всех подходов примерно одинакова.

• Предоставить дополнительную поддержку для параллельного выполнения: здесь уже сказано, что возможность выполнения функционального интерфейса Iterable#forEach параллельно с использованием streamов является, безусловно, важным аспектом. Поскольку Collection#parallelStream() не гарантирует, что цикл фактически выполняется параллельно, необходимо учитывать это необязательную функцию. Итерируя по списку с list.parallelStream().forEach(...); , вы явно говорите: этот цикл поддерживает параллельное выполнение, но он не зависит от него. Опять же, это особенность, а не дефицит!

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

   public abstract class MyOptimizedCollection implements Collection{ private enum OperatingSystem{ LINUX, WINDOWS, ANDROID } private OperatingSystem operatingSystem = OperatingSystem.WINDOWS; private int numberOfCores = Runtime.getRuntime().availableProcessors(); private Collection delegate; @Override public Stream parallelStream() { if (!System.getProperty("parallelSupport").equals("true")) { return this.delegate.stream(); } switch (operatingSystem) { case WINDOWS: if (numberOfCores > 3 && delegate.size() > 10000) { return this.delegate.parallelStream(); }else{ return this.delegate.stream(); } case LINUX: return SomeVerySpecialStreamImplementation.stream(this.delegate.spliterator()); case ANDROID: default: return this.delegate.stream(); } } } 

  Приятно, что ваша реализация цикла не должна знать или заботиться об этих деталях.

forEach() может быть реализована быстрее, чем для каждого цикла, потому что итеративный знает лучший способ повторить его элементы, в отличие от стандартного iteratorа. Таким образом, разница – это внутренняя или внутренняя петля.

Например, ArrayList.forEach(action) может быть просто реализовано как

 for(int i=0; i 

 Iterator iter = list.iterator(); while(iter.hasNext()) Object next = iter.next(); do something with `next` в Iterator iter = list.iterator(); while(iter.hasNext()) Object next = iter.next(); do something with `next`