Java 8 Iterable.forEach() vs foreach-Schleife

Question

Welche der folgenden Praktiken ist in Java 8 besser?

Java 8:

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

Java 7:

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

Ich habe viele for-Schleifen, die mit Lambdas "vereinfacht" werden könnten, aber gibt es wirklich einen Vorteil, sie zu verwenden? Würde es ihre Leistung und Lesbarkeit verbessern?

EDIT

Ich werde diese Frage auch auf längere Methoden ausdehnen. Ich weiß, dass man von einer Lambda-Funktion aus die übergeordnete Funktion nicht zurückgeben oder beenden kann und dies sollte ebenfalls berücksichtigt werden, wenn man sie vergleicht, aber gibt es noch etwas anderes zu beachten?

Answer 1

Eine der ärgerlichsten funktionalen Einschränkungen von forEach ist das Fehlen der Unterstützung für geprüfte Ausnahmen.

Ein möglicher Workaround besteht darin, das Terminal forEach durch eine einfache alte foreach-Schleife zu ersetzen:

    Stream stream = Stream.of("", "1", "2", "3").filter(s -> !s.isEmpty());
    Iterable iterable = stream::iterator;
    for (String s : iterable) {
        fileWriter.append(s);
    }

Hier ist eine Liste der beliebtesten Fragen mit anderen Workarounds zur Behandlung von geprüften Ausnahmen in Lambdas und Streams:

Java 8 Lambda-Funktion, die eine Ausnahme wirft?

Java 8: Lambda-Streams, Filtern nach Methode mit Ausnahme

Wie kann ich GEPRÜFTE Ausnahmen aus Java 8 Streams werfen?

Java 8: Erforderliche Behandlung geprüfter Ausnahmen in Lambda-Ausdrücken. Warum verpflichtend und nicht optional?

Answer 2

Der Vorteil der Java 1.8 forEach-Methode gegenüber der 1.7 Enhanced-for-Schleife besteht darin, dass Sie sich beim Schreiben des Codes nur auf die Geschäftslogik konzentrieren können.

Die forEach-Methode nimmt ein Objekt java.util.function.Consumer als Argument, so dass Sie Ihre Geschäftslogik an einem separaten Ort haben und sie jederzeit wiederverwenden können.

Werfen Sie einen Blick auf den untenstehenden Auszug:

• Hier habe ich eine neue Klasse erstellt, die die Methode accept der Consumer-Klasse überschreiben wird, in der Sie zusätzliche Funktionen, mehr als nur Iteration, hinzufügen können..!!!!!!

  class MyConsumer implements Consumer{
  
      @Override
      public void accept(Integer o) {
          System.out.println("Hier können Sie auch Ihre Geschäftslogik hinzufügen, die mit der Iteration funktioniert und die Sie wiederverwenden können."+o);
      }
  }
  
  public class ForEachConsumer {
  
      public static void main(String[] args) {
  
          // Erstellen eines einfachen ArrayList.
          ArrayList aList = new ArrayList<>();
          for(int i=1;i<=10;i++) aList.add(i);
  
          //Aufruf von forEach mit angepasstem Iterator.
          MyConsumer consumer = new MyConsumer();
          aList.forEach(consumer);
  
          // Verwendung von Lambda-Ausdruck für Consumer. (Funktionale Schnittstelle) 
          Consumer lambda = (Integer o) ->{
              System.out.println("Verwendung von Lambda-Ausdruck zum Iterieren und Ausführen einer anderen Aktion (BI).. "+o);
          };
          aList.forEach(lambda);
  
          // Verwendung einer anonymen Inneren Klasse.
          aList.forEach(new Consumer(){
              @Override
              public void accept(Integer o) {
                  System.out.println("Aufruf mit anonymer Innerer Klasse "+o);
              }
          });
      }
  }