Lambda Expressions

Lambda Expressions sind cool. Das Feature bietet eine Vielzahl von Vorteilen.

Meiner Meinung sind Lambda Expression eine tolle Sache, da das Feature

– die Verwendung von Single Abstract Method-Interfaces vereinfacht
– mittels Functional Interfaces Logik implementieren kann ohne das zusätzlich eine Klasse geschrieben werden muss
– und mit neuen der Stream API eine bessere Verteilung und Auslastung von Multicore Prozessoren erlangt.

Java-Entwickler erhalten eine präzisere Syntax zur Verfügung stellt, der Runtime Overhead ist gegenüber anonymen Klassen geringer und es gibt noch weitere tolle Features wie Methodenreferenzen.

Wie ihr JDK 8 und Eclipse zusammen nutzen könnte, habe ich ja schon beschrieben.

Beispiel

Hier jetzt mal ein einfaches HelloWorld Beispiel, um zu zeigen, wie einfach das ist.

public interface Hello {
    String greet(String name);
}

Und hier die Main-Class mit der Lambda Expression

public class HelloWorld {

    public static void main(String[] args) {
        Hello hello = (String name) -> {
            return "Hello " + name;
        };

        System.out.println(hello.greet("du!"));
    }

}

Syntax

Die Syntax von Lambda Expression ist einfach.

  (formal parameter list) ->{ expression or statements }

Es wird eine kommaseparierte Liste mit Parametern rein gegeben, die dann in der Lambda Expression verwendet werden können. Der Parameterliste folgt der -> Operator. Danach kommt der Lambda Body, der aus einem Statement oder einen Block bestehen kann. Return Typ ist dann void oder ein beliebiger Referenz Typ, ein Java Typ oder ein primitiver Typ. Wichtig ist noch, dass der Block mit geschweiften Klammern eingeschlossen wird, wenn der Rückgabe nicht void ist.

Functional Interfaces

In Java werden Lambda Expression zusammen mit Functional Interface benutzt. Ein Functional Interface ist ein Interface mit nur einer abstrakten Methode, java.util.concurrent.Callable mit call() ist ein Beispiel. Bei Lambdas muss nicht explizit das Interface angegeben werden. Der Target Type der Expression wird aus dem Kontext ermittelt, also:

– aus einer Variablen Deklaration,
– einer Zuweisung,
– Return Statement,
– wo ein Array initialisiert wird,
– Methoden- oder Konstruktorparametern,
– einem Lambda Expression Body
– einem bedingten Ausdruck
– oder einem Cast.

Wichtig aber ist, dass alle Exceptions, die auftreten können, im Functional Interface berücksichtigt werden, auf die in einer Lambda Expression reagiert werden soll. Aber das ist eigentlich klar, denn das ist ja auch schon mit normalen Interfaces so.

Sonstiges

Hier noch eine kleine Auflistung von Dingen, die mir bei der Arbeit mit Lambdas aufgefallen sind:

– Lambda Expressions sind wie eine anonyme Methoden. Die Implementierung muss der Schnittstelle genügen, du kannst Parameter spezifizieren und es kann ein Wert zurückgegeben werden.
– Damit ich innerhalb einer Lambda Expression auf z.B. lokale Variablen zugreifen kann, müssen diese den final Modifier haben.
– this und super Referenzen sind die des um umgebenen Kontext. Die Lambda Expressions führen keinen neuen Scope ein.
– Der Lambda Expression Parameter Name muss sich von Variablen unterscheiden, die im Kontext schon existieren

Fazit

Je mehr ich mit Lambda Expressions arbeite, desto mehr Spaß bringen sie. Das Feature hilft mir Logik mit weniger Zeilen Code zu implementieren. Weitere Beispiele findet ihr auf github:

https://github.com/claudioaltamura/java8/tree/master/defaultmethods