Ullrich am 12. Dezember 2022 um 23:06 Uhr

2022-12-12T23:06:20Z

Ullrich am 12. Dezember 2022 um 22:18 Uhr

2022-12-12T22:18:18Z

Ullrich: Ullrich verschob die Seite Einführung in Java-Lambdas nach Java-Lambdas Einführung, ohne dabei eine Weiterleitung anzulegen

2021-04-21T20:36:52Z

Ullrich verschob die Seite Einführung in Java-Lambdas nach Java-Lambdas Einführung, ohne dabei eine Weiterleitung anzulegen

← Nächstältere Version	Version vom 21. April 2021, 20:36 Uhr
(kein Unterschied)

Ullrich am 9. April 2021 um 17:06 Uhr

2021-04-09T17:06:16Z

← Nächstältere Version		Version vom 9. April 2021, 17:06 Uhr
Zeile 4:		Zeile 4:
	funktionalen Programmiersprachen wie LISP, Haskell, Clojure oder Scala aufsetzen und das sich fundamental vom		funktionalen Programmiersprachen wie LISP, Haskell, Clojure oder Scala aufsetzen und das sich fundamental vom
	Modell der Turing-Maschine unterscheidet, das den imperativen Sprachen wie Java oder C zugrunde liegt.		Modell der Turing-Maschine unterscheidet, das den imperativen Sprachen wie Java oder C zugrunde liegt.
	Der Name leitet sich vom griechischen Buchstaben {{~~lambda~~}} ab den Church für seine Notation verwendete.		Der Name leitet sich vom griechischen Buchstaben {{Lambda}} ab den Church für seine Notation verwendete.
	Weil das kürzer ist -- und cooler aussieht -- steht im Folgenden {{lambda}} für "Lambda".		Weil das kürzer ist -- und cooler aussieht -- steht im Folgenden {{lambda}} für "Lambda".

Ullrich: Die Seite wurde neu angelegt: „Category:Java Der Begriff "Lambda-Ausdruck" entstammt dem Lambda-Kalkül mit dem sich Alonzo Church in den 1930er Jahren anschickte eine formale Spezifikat…“

2021-04-09T17:03:55Z

Die Seite wurde neu angelegt: „Category:Java Der Begriff "Lambda-Ausdruck" entstammt dem Lambda-Kalkül mit dem sich Alonzo Church in den 1930er Jahren anschickte eine formale Spezifikat…“

Neue Seite

[[Category:Java]]
Der Begriff "Lambda-Ausdruck" entstammt dem Lambda-Kalkül mit dem sich Alonzo Church in den 1930er Jahren
anschickte eine formale Spezifikation der Mathematik zu schaffen. Dabei hat er ein Konzept entwickelt, auf dem die
funktionalen Programmiersprachen wie LISP, Haskell, Clojure oder Scala aufsetzen und das sich fundamental vom
Modell der Turing-Maschine unterscheidet, das den imperativen Sprachen wie Java oder C zugrunde liegt.
Der Name leitet sich vom griechischen Buchstaben {{lambda}} ab den Church für seine Notation verwendete.
Weil das kürzer ist -- und cooler aussieht -- steht im Folgenden {{lambda}} für "Lambda".

Im nachfolgenden Artikel wird gezeigt, was {{lambda}}-Ausdrücke in Java sind und wie man sie anwenden kann. Es
wird hier nur ein Überblick gegeben, die Verwendungsmöglichkeiten von {{lambda}}-Ausdrücken sind immens vielseitig.
Was also ist ein {{lambda}} oder besser gesagt ein {{lambda}}-Ausdruck?

:<q>Ein Lambda-Ausdruck definiert eine einzelne Funktion deren Typ bestimmt ist durch die Typen ihrer Parameter-Liste und ihres Ergebnis-Typs.</q>

Das klingt abstrakt und sehr akademisch. Aber behalten wir diese Aussage im Hinterkopf, wenn wir im Folgenden
an einem Beispiel die Verwendung von {{lambda}}-Ausdrücken in Java erkunden.

Es sei nicht verschwiegen, daß in obiger Definition ein Detail weggelassen wurde. Für den Typ des {{lambda}}-Ausdruck
ist in Java auch die {{java|throws}}-Klausel der Methode von Bedeutung. Was das bedeutet wird später erläutert.

== Ein Beispiel mit konventionellen Java-Mitteln ==
Wir haben hier eine Methode, die die Zahlen einer Liste durchgeht und zu jedem Wert der Liste den Wert 1
hinzuzählt. Die bearbeiteten Zahlen werden in einer neuen Liste als Ergebnis zurückgegeben:
{{java|code=
public List<Integer> verarbeite(List<Integer> liste) {
List<Integer> result = new ArrayList<>();
for (Integer x : liste) {
result.add(x + 1);
}
return result;
}
}}
Jedesmal, wenn eine andere Funktion (als "plus eins") zur Berechnung verwendet werden soll, muß die Methode kopiert und angepaßt werden – nicht schön.
Man kann die Methode aber auch mit konventionellen Mitteln so erweitern, daß auf die Zahlen eine beliebige Funktion angewandt werden kann.
Dafür definiert man zunächst ein Interface
{{java|code=
interface Funktion {
Integer calc(Integer x);
}
}}
Nun erweitert man die Methode so, daß sie eine Instanz dieses Interfaces als Argument übernimmt und
anstelle des fest verdrahteten Ausdrucks {{java|x + 1}} für die Verechnung verwndet:
{{java|code=
public List<Integer> verarbeite(List<Integer> liste, Funktion fkt) {
List<Integer> result = new ArrayList<>();
for (Integer x : liste) {
result.add(fkt.calc(x));
}
return result;
}
}}
Um die Methode {{java|verarbeite()}} verwenden zu können benötigen wir ein Objekt, das das Interface {{java|Funktion}} implementiert.
Nur mit einem solchen Objekt kann die Methode verwendet werden. Möchten wir zum Beispiel folgende Klasse verwenden:
{{java|code=
class Calc {
public Integer doppel(Integer x) {
return 2 * x;
}
}
}}
benötigen wir zusätzlich einen Wrapper oder Adapter der die Methode {{java|doppel}} auf die Methode {{java|calc}} des Interface {{java|Funktion}}
abbildet. Anstelle einer eigenen Klasse kann man beim Aufruf von {{java|bearbeite}} ein Objekt einer anonymen Klasse instantiieren:
{{java|code=
verarbeite(meineListe, new Funktion() {
public Integer calc(Integer x) {
return new Calc().doppel(x);
}
});
}}
Und das ist so unübersichtlich wie aufwendig.

== Und jetzt mit Lambdas ==
Um uns dem Problem zu nähern, beginnen wir diesmal bei der Funktion die auf die Zahlen angewandt werden soll.
Das ist zunächst die Inkrementierungs-Funktion.

Wir definieren dafür eine Variable und weisen ihr einen {{lambda}}-Ausdruck zu, der die Inkrementierungs-Funktion implementiert.
im Anschluß wird der Ausdruck ausführlich beschrieben. Vollständig ausgeschrieben sieht das so aus:
{{java|code=Function<Integer, Integer> foo = (Integer x) -> {return x+1;};}}
Wir wenden uns zunächst der ''rechten'' Seite der Zuweisung zu, das ist der eigentliche Lamnda-Ausdruck.
Den Typ der Variable {{java|foo}} nehmen wir im nächsten Abschnitt unter die Lupe.

Ein {{lambda}}-Ausdruck entspricht der Definition einer mathematischen Funktion.
Links des {{java|->}}-Operators steht die Parameter-Liste (die Parameter
werden durch Komma getrennt, im Beispiel haben wir nur einen Parameter). Rechts des Operators steht der
auszuwertende Ausdruck, ein – nahezu – beliebiger Ausdruck, der einen Wert des Ergebnistyps (hier: {{java|Integer}}) liefert.

Um den Ausdruck kompakter und dadurch übersichtlicher zu machen, lassen sich einige Teile weglassen:

Besteht der Ausdruck lediglich aus einem {{java|return}}-Statement, kann man die Klammern samt {{java|return}} weglassen:
{{java|code=Function<Integer, Integer> foo = (Integer x) -> x + 1;}}
Wenn aus dem Kontext klar ist, welche Typen die Parameter der Parameter-Liste haben, kann man auch die Typen weglassen:
{{java|code=Function<Integer, Integer> foo = (x) -> x + 1;}}
Wenn die Parameter-Liste nur einen einzigen Parameter enthält, können wir die Klammern um den Parameter weglassen:
{{java|code=Function<Integer, Integer> foo = x -> x + 1;}}
Wir können die Methode nun so umschreiben, daß sie unseren {{lambda}}-Ausdruck akzeptiert:
{{java|code=
public List<Integer> verarbeite(List<Integer> liste, Function<Integer, Integer> fkt) {
List<Integer> result = new ArrayList<>();
for (Integer x : liste) {
result.add(fkt.apply(x));
}
return result;
}
}}
Auf den Ausdruck {{java|fkt.apply(x)}} werden wir später zurückkommen, einstweilen genügt uns zu wissen, daß damit der
{{lambda}}-Ausdruck {{java|fkt}} mit dem Argument {{java|x}} ausgewertet wird. Wir können die Methode {{java|verarbeite()}} nun so aufrufen:
{{java|code=verarbeite(liste, x -> x + 1);}}
und der Aufruf mit dem Wrapper um die Klasse {{java|Calc}} sieht nun so aus:
{{java|code=verarbeite(liste, x -> new Calc().doppel(x));}}
Wenn das mal kein Fortschritt ist –- und es wird noch besser!

=== Funktionale Interfaces ===
Betrachten wir nun den ''Typ'' des {{lambda}}-Ausdrucks. {{java|Function}} ist ein generisches Interface des JDK, das eine
einzige Methode definiert:
{{java|code=
public interface Function<T, R> {
R apply(T t);
}
}}
Man könnte sagen, daß der {{lambda}}-Ausdruck einer gedachten Klasse {{java|MyFunction}} entspricht die so aussieht:
{{java|code=
class MyFunction {
Integer apply(Integer t){
return t + 1;
}
}
}}
Der Unterschied des {{lambda}}-Ausdrucks zur Methode besteht darin, daß der {{lambda}}-Ausdruck gleichwertig ist mit jeder Methode jeder Klasse deren Parameter-Liste die gleichen Typen hat (also hier einen {{java|Integer}}) und den gleichen
Ergebnis-Typ (hier ebenfalls {{java|Integer}}). Konkret heißt das, daß das {{lambda}} die Methode {{java|calc}} aus unserem Ausgangs-Interface implementiert:
{{java|code=
interface Funktion {
Integer calc(Integer x);
}
}}
Diese Äquivalenz geht sogar noch einen Schritt weiter: Das {{lambda}} {{java|foo}} implementiert jedes Java-Interface das
genau eine nicht-statische Methode hat die einen {{java|Integer}} als Parameter übernimmt und einen {{java|Integer}} als Ergebnis
liefert. Das {{lambda}} {{java|foo}} implementiert die einzige Methode des Interface {{java|Funktion}} und kann überall dort verwendet
werden, wo ein Objekt verlangt wird das das Interface {{java|Funktion}} implementiert – wir hätten unsere Methode also
gar nicht auf das JDK-Interface {{java|Function}} umzuschreiben brauchen (naja, hätten wir gleich mit {{lambda}}-Ausdrücken
angefangen, hätten wir von Anfang an das JDK-Interface verwendet).

Interfaces, die der genannten Regel entsprechen und genau eine nicht-statische Methode haben heißen in Java
"functional Interfaces" und werden meist mit der Annotation {{java|@FunctionalInterface}} versehen. Die Annotation ist nicht
erforderlich, aber hilfreich. Der JDK bietet im Package {{java|java.util.function}} eine ganze Reihe nützlicher Interfaces an,
aber es steht dem Entwickler frei, beliebige Interfaces zu definieren. Bisweilen ist es auch hilfreich nicht die JDK-Interfaces
zu verwenden wenn das Wording nicht zu hundert Prozent paßt.

=== Methoden als Lambda-Ausdruck ===
Kommen wir nun zu einigen alternativen Varianten, {{lambda}}-Ausdrücke zu schreiben die genau eine existierende
Methode aufrufen.
===== statische Methoden =====
Beginnen wir mit statischen Methode. Die JDK-Klasse {{java|Math}} besitzt eine Methode {{java|abs()}} die den Absolutwert einer
Integerzahl berechnet:
{{java|code=
public static int abs(int a) {
return (a < 0) ? -a : a;
}
}}
An dieser Stelle sei darauf hingewiesen, daß wir hier durch das Autoboxing von Java die Typen {{java|Integer}} und {{java|int}}
jederzeit gegen einander austauschen können.
Wir können diese Methode nun so verwenden wie oben und in einen {{lambda}}-Ausdruck verpacken:
{{java|code=
verarbeite(liste, x -> Math.abs(x));
}}
Wir können die Methode aber auch mit dem {{java|::}}-Operator referenzieren. Dabei wird die Klasse links des Operators
angegeben und Name der Methode rechts:
{{java|code=
verarbeite(liste, Math::abs);
}}

==== nicht-statische Methoden ====
Das geht auch mit nicht-statischen Methoden. Allerdings benötigen wir dafür ein Objekt auf das sich die Methode
bezieht. Befindet sich die Methode in der gleichen Klasse, können wir {{java|this}} verwenden:
{{java|code=
verarbeite(liste, this::doppel);
}}
Natürlich kann man auch eine Variable verwenden:
{{java|code=
Calc c = new Calc();
verarbeite(liste, c::doppel);
}}
oder ein Objekt in place erzeugen:
{{java|code=
verarbeite(liste, new Calc()::doppel);
}}
Tatsächlich darf auf der linken Seite des {{java|::}}-Operators ein beliebiger Ausdruck stehen der ein Objekt liefert, also zum
Beispiel eine Methode – statisch oder auch nicht – die ein Objekt liefert.

==== Statische Referenz nicht-statischer Methoden ====
Die dritte Variante ist auf den ersten Blick ausgesprochen verwirrend, weil sie die beiden vorangegangenen
Varianten zu vermischen scheint.

Tatsächlich ist es aber vermutlich die am häufigsten eingesetzte Variante und ist beim Arbeiten mit Streams und Optionals
unverzichtbar.

Nehmen wir uns also etwas mehr Zeit dafür:

Wie bei der ersten Variante schreibt man den Namen der Klasse auf der linken Seite des {{java|::}}-Operators
und den Namen der (nicht-statischen) Methode auf der rechten Seite:
{{java|code=
String::trim
}}
Während die ersten beiden Varianten noch intuitiv verständlich sein dürften, muß man sich fragen, wie
''dieser'' Ausdruck zu interpretieren ist.
Die Methode {{java|trim()}} der Klasse {{java|String}} ist nicht statisch. Sie wird auf ein {{java|String}}-Objekt angewandt und liefert als Ergebnis ebenfalls einen String. Da stellt sich zunächst die Frage, welches funktionale Interface die Methode implementiert?
Probiert man das aus erhält man folgendes verblüffende Ergebnis:
{{java|code=
Function<String, String> mapper = String::trim;
}}
Dann ist {{java|trim()}} also eine Methode, die einen String als Eingabe hat und einen String als Ergebnis liefert?
Ganz falsch ist diese Interpretation nicht, wenn man sich vorstellt, daß der String der getrimmt werden soll nicht in
der Klammer steht, sondern vor dem Punkt:
{{java|code=
String foo = " mit Leerzeichen ";
foo = foo.trim();
}}
Und genauso wird der Ausdruck {{java|String::trim}} verwendet. Man benutzt ihn, wenn man eine Methode angeben
möchte, die auf ein Objekt angewendet werden soll (in diesem Falle vom Typ {{java|String}}).
Die Notation {{java|String::trim}} könnte man als "normalen" {{lambda}}-Ausdruck auch so schreiben:
{{java|code=
(String s) -> {return s.trim();}
}}
Dieser {{lambda}}-Ausdruck definiert eine Funktion, die einen String als Parameter übernimmt und dann die Methode {{java|trim()}}
auf diesen Parameter anwendet.
Gerade diese letzte Variante wirkt ohne praktische Anwendung ziemlich akademisch, In der [[Optional|Einführungen zu Optionals]] gibt es einige praktische Anwendungsbeispiele für solche {{lambda}}-Ausdrücke.

=== Lambdas mit Kontext ===
Die oben vorgestellte, zweite Variante läßt sich – anders als die Variante mit der statischen Methode – nicht ohne
weiteres als "normaler" {{lambda}}-Ausdruck schreiben, da zur Ausführung ein Objekt benötigt wird. Hier sehen wir
eine weitere Eigenschaft von {{lambda}}-Ausdrücken: Man kann ihnen nämlich aus dem sie umgebenden Kontext
Daten mitgeben:
{{java|code=
Calc rechner = new Calc();
Function<Integer, Integer> fkt = (Integer x) -> rechner.doppel(x);
this.verarbeite(liste, fkt);
}}
Was geschieht hier? Wir erzeugen zunächst ein Objekt {{java|rechner}} von Typ {{java|Calc}} und bauen dann einen {{lambda}}-Ausdruck
der das Objekt {{java|rechner}} verwendet um die Methode {{java|doppel()}} mit einem Integer-Wert auszuführen der als Parameter mitgegeben wird.

Das Objekt kommt aus dem Kontext des {{lambda}}-Ausdrucks (der Methode in der der Ausdruck erzeugt wird) und
wird dem {{lambda}}-Ausdruck mitgegeben. Man kann dieses Verhalten zum Beispiel dazu nutzen, {{lambda}}-Ausdrücke
mit einer Methode zu erzeugen um sie dann an anderer Stelle zu verwenden:
{{java|code=
public Function<Integer, Integer> getRechner() {
Calc rechner = new Calc();
return (Integer x) -> rechner.doppel(x);
}

public void rechne() {
this.verarbeite(liste, getRechner());
}
}}
Die Methode {{java|getRechner}} erzeugt das {{java|Calc}}-Objekt und baut es in den {{lambda}}-Ausdruck ein.
Wenn die Methode {{java|rechne()}} das {{lambda}} von {{java|getRechner}} als Ergebnis erhält, ist die Methode {{java|getRechner()}}
zu Ende gelaufen, aber das Objekt das die Variable {{java|rechner}} referenziert lebt im {{lambda}}-Ausdruck weiter und wird
nun bei der Verarbeitung verwendet.

Dabei muß man zwei Dinge beachten:
Die Variable {{java|rechner}}, die das Objekt enthält das hier in den {{lambda}}-Ausdruck eingearbeitet wird,
muß "effektiv final" sein. Das heißt, ihr Inhalt darf nach der Zuweisung nicht mehr verändert werden.
Folgender Code wird daher ''nicht'' kompilieren, da {{java|rechner}} nachträglich verändert wird:
{{java|code=
public Function<Integer, Integer> getRechner() {
Calc rechner = new Calc();
Function<Integer, Integer> fkt = (Integer x) -> rechner.doppel(x);
rechner = new Calc();
return fkt;
}
}}
Das Objekt das durch die Variable {{java|rechner}} referenziert wird kann aber sehr wohl verändert werden.
Dadurch kann sich das Verhalten des {{lambda}}-Ausdrucks ändern. Das ist ein generelles Problem in Java,
das keine unveränderbare (immutable) Objekte kennt. Es ist dringend davon abzuraten, solches Verhalten
in {{lambda}}-Ausdrücke einzuarbeiten, auch wenn es auf den ersten Blick sehr elegant wirkt.
Solches Seiteneffekte führen sehr gerne zu obskuren Fehlern, die nur schwer zu debuggen sind.

Java-Lambdas Einführung - Versionsgeschichte

Ullrich am 12. Dezember 2022 um 23:06 Uhr

Ullrich am 12. Dezember 2022 um 22:18 Uhr

Ullrich: Ullrich verschob die Seite Einführung in Java-Lambdas nach Java-Lambdas Einführung, ohne dabei eine Weiterleitung anzulegen

Ullrich am 9. April 2021 um 17:06 Uhr

Ullrich: Die Seite wurde neu angelegt: „Category:Java Der Begriff "Lambda-Ausdruck" entstammt dem Lambda-Kalkül mit dem sich Alonzo Church in den 1930er Jahren anschickte eine formale Spezifikat…“