Funktionale Programmierung in Java

Eine umfassende Einführung

Herbert Prähofer

• Verlag: dpunkt.verlag
• Jahr: 2020
• ISBN drucken: 9783864907579
• eBook-ISBN: 9783960889854
• Thema: Informatik
• Thema: Programmierung

Ihr Weg vom objektorientiertem zum funktionalem Java

• Was ist Funktionale Programmierung?
• Wie funktioniert Funktionale Programmierung in Java?
• Was sind Techniken, Muster und Best Practices für den Einsatz von Funktionaler Programmierung in Java?

"Funktionale Programmierung in Java" eignet sich sowohl für Java-Einsteiger, die sich die funktionalen Aspekte von Java genauer ansehen wollen, als auch für erfahrene Java-Entwickler, die ihre objektorientierten Kenntnisse um funktionalen Konzepte erweitern wollen. Nach der Lektüre wissen sie, wie Sie mit Ansynchronität und Nebenläufigkeit umgehen können. Streams, Monaden und Co. werden Ihren Programmierstil bereichern.

1Einleitung

Mit der Version 8 wurden auch in Java Lambda-Ausdrücke eingeführt. Auf den ersten Blick erscheinen diese neben den vielen anderen Sprachfeatures von Java nur als ein weiterer kleiner Zusatz. Tatsächlich bedeutet aber ihre Einführung und die damit einhergehende Unterstützung eines funktionalen Programmierstils einen revolutionären Wandel in der Art, wie man Programme in Java gestalten kann. Funktionale Programmierung verspricht eine Programmgestaltung, die in deklarativer Form, auf hohem Abstraktionsniveau, knapp und präzise und für eine parallele Ausführung geeignet ist. Funktionale Programmierung ist grundsätzlich unterschiedlich zur imperativen Programmierung, sie steht aber nicht im Gegensatz zur objektorientierten Programmierung. Wie Brian Goetz es in seinem Vorwort zu [56] ausdrückt, arbeitet Objektorientierung mit einer Abstraktion entlang der Daten, die funktionale Programmierung erlaubt aber eine Abstraktion von Verhaltensstrukturen. Damit ergänzen sich die beiden Paradigmen zu einer neuen Qualität der Programmgestaltung.

Funktionale Programmierung hat besonders in den letzten Jahren viel Aufmerksamkeit erhalten. Dabei ist funktionale Programmierung kein neues Paradigma. Tatsächlich ist die erste funktionale Programmiersprache Lisp fast so alt wie die erste imperative Programmiersprache Fortran. Die Entwicklung der theoretischen Grundlagen zur funktionalen Programmierung, der Lambda Kalkül [17], reicht sogar bis in die 1930er-Jahre zurück. Heute wird funktionale Programmierung von den meisten Programmiersprachen unterstützt.

Mehrere Entwicklungen sind wohl dafür verantwortlich, dass die funktionale Programmierung, die über so viele Jahre ein mehr oder weniger akademisches Nischendasein fristete, jetzt vom Mainstream der Programmierwelt aufgegriffen wurde:

• Mit dem Aufkommen von Prozessoren mit mehreren Kernen werden Softwarekonzepte für eine parallele Ausführung benötigt.
• Mit der zunehmenden Vernetzung, mit Systemen, die ständig online verbunden sind, mit Serverarchitekturen, die zehntausende Klienten gleichzeitig bedienen müssen, und Internet of Things-Anwendungen, die ständig auf Änderungen in der Umwelt reagieren sollen, versagen bisherige Paradigmen der Programmierung.

Und gerade die funktionale Programmierung wird als Mittel gesehen, diesen Herausforderungen zu begegnen.

Eigenschaften funktionaler Programme

Funktionale Programmierung beruht auf mathematischen Funktionen. In der Mathematik ist eine Funktion eine Abbildung einer Menge von Elementen des Definitionsbereichs D in eine weitere Menge von Elementen des Wertebereichs Z:

f : D → Z, x

y

Jedem Element des Definitionsbereichs wird ein eindeutiger Wert des Wertebereichs zugeordnet. Praktisch heißt dies, dass eine Funktion bei gleichem Argumentwert immer den gleichen Ergebniswert liefern muss. Eine Funktion kann damit weder ein Gedächtnis haben, noch darf sie Seiteneffekte verursachen. Der einzige Mechanismus, der durch eine Funktion zur Verfügung gestellt wird, ist die Anwendung der Funktion auf Argumente, für die die Funktion ein eindeutiges Resultat liefert. Man spricht dann von rein-funktionaler Programmierung.

Eine rein-funktionale Programmierung beruht daher ausschließlich auf Funktionsdefinition und Funktionsanwendung. Die so vertrauten Konzepte der veränderlichen Variablen und Wertzuweisungen gibt es nicht, tatsächlich gibt es überhaupt keine veränderlichen Daten. Funktionale Programmierung unterscheidet sich damit grundsätzlich von imperativer Programmierung, die immer mit Zuweisungen von Werten an Variablen und Verändern eines Programmzustands arbeitet.

Funktionale Programme haben im Vergleich zu Programmen mit Seiteneffekten eine Reihe von günstigen Eigenschaften. Eine Funktion ist in sich abgeschlossen, weil sie nur von den Argumenten abhängt. Sie kann daher als eine Einheit angewendet, verstanden, getestet und verifiziert werden. Eine Funktionsanwendung steht ausschließlich für den Wert, den sie berechnet, und sie kann folglich zu jedem Zeitpunkt durch seinen Wert ersetzt werden. Das macht funktionale Programme unabhängig von einem Kontrollfluss und Funktionsanwendungen können in beliebiger Reihenfolge, parallel oder nach Bedarf erfolgen.

Aber ist dieses Modell, mit Funktionen mit Rückgabewerten und mit Funktionsanwendungen zu arbeiten, nicht viel zu restriktiv? Ist funktionale Programmierung damit im Vergleich zur imperativen Programmierung weniger mächtig und flexibel? Wie im wegweisenden Artikel von John Hughes mit dem Titel »Why functional programming matters« [32] eindrucksvoll argumentiert wird, liegt die Mächtigkeit der funktionalen Programmierung in der besseren Modularität und Kombinierbarkeit von Funktionen. Dadurch, dass Funktionen in sich abgeschlossen und nicht von einer Umgebung abhängig sind, können Funktionen frei kombiniert werden.

Besonders bemerkenswert ist auch, dass gerade John Backus, der mit der Entwicklung von Fortran [7] und mit seiner Mitarbeit bei der Definition von Algol 60 [6] ganz wesentlich zur Entwicklung der imperativen Programmiersprachen beigetragen hat, zu den Schwächen der imperativen Programmierung und zur Mächtigkeit der funktionalen Programmierung sehr früh grundlegende Einsichten gab. In seiner Ansprache zur Verleihung des Turing Awards hat er sich mit sehr drastischen Worten gegen die imperative Programmierung gewandt und eine funktionale Programmierung propagiert. Aus der begleitenden Publikation mit dem vielsagenden Titel »Can Programming Be Liberated From the von Neumann Style? A Functional Style and Its Algebra of Programs« [8] ist dazu folgende Aussage entnommen:

Conventional programming languages are growing ever more enormous, but not stronger. Inherent defects at the most basic level cause them to be both fat and weak: their primitive word-at-a-time style of programming inherited from their common ancestor–the von Neumann computer, their close coupling of semantics to state transitions, their division of programming into a world of expressions and a world of statements, their inability to effectively use powerful combining forms for building new programs from existing ones, and their lack of useful mathematical properties for reasoning about programs.

Backus sieht also die Schwäche der imperativen Programmierung in der engen Anlehnung an das Verarbeitungsmodell des von Neumann-Rechners. Und er vermisst mächtige Kombinationsoperatoren zur Gestaltung von Programmen auf höherer Ebene. Der Artikel propagiert dann einen funktionalen Programmierstil mit Operatoren zur Kombination von funktionalen Bausteinen. Er schreibt dazu:

An alternative functional style of programming is founded on the use of combining forms for creating programs. [...] Associated with the functional style of programming is an algebra of programs whose variables range over programs and whose operations are combining forms.

Backus hat damit früh den Weg der Entwicklung funktionaler Sprachen vorgezeichnet. Sehr anschaulich ist auch das Beispiel im Artikel, mit dem imperative Programmierung und funktionale Programmierung verglichen werden. Eine imperative Lösung des Skalarproduktes von Vektoren, folgend mit zwei Listen a und b mit Länge n, gestaltet sich in Java folgendermaßen:

int c = 0;

for (int i = 0; i < n; i++) {

c = c + a.get(i) * b.get(i);

}

Die Lösung baut auf der Wertzuweisung auf. Das Ergebnis wird in der Variablen c akkumuliert. In jedem Schleifendurchlauf wird in einer Wertzuweisung ein nächster Wert für c berechnet und gespeichert. Die Berechnung ist, wie Backus es kritisiert, »word-at-a-time style«.

Die im Artikel dann vorgeschlagene Lösung, übersetzt auf die heute übliche Form funktionaler Sprachen, sieht im Gegensatz dazu folgendermaßen aus:

map2((x, y) -> x * y).andThen(reduce((r, x) -> r + x))

Die Operationen beziehen sich nicht auf einzelne Elemente, sondern auf die Vektoren als Ganzes. Sie sind mit Verknüpfungsoperationen in der Form von Lambda-Ausdrücken parametrisiert. Mit map2 werden die Elemente zweier Vektoren paarweise mit der angegebenen Verknüpfungsoperation verknüpft. Die Operation reduce verknüpft die Elemente eines Vektors zu einem einzelnen Wert. Mit andThen werden Funktionen in Serie geschaltet. Somit werden in obiger Definition zuerst die Elemente von zwei Vektoren multipliziert und schließlich alle Produkte addiert. Das entspricht exakt der mathematischen Definition des Skalarprodukts. Im Gegensatz zur obigen imperativen Lösung ist diese Definition deklarativ und auf hoher Ebene. Die Operationen beziehen sich nicht auf ...

Inhaltsverzeichnis

• Cover
• Über den Autor
• Titel
• Impressum
• Inhaltsverzeichnis
• Vorwort
• 1 Einleitung
• 2 Sprachliche Grundlagen
• 3 Programmieren ohne Seiteneffekte
• 4 Programmieren mit Funktionsparametern
• 5 Kombination von Funktionen
• 6 Funktoren, Monoide und Monaden
• 7 Streams
• 8 Parallele Streams
• 9 Asynchrone Funktionsketten
• 10 Reaktive Streams
• 11 Testen mit und von Funktionen
• 12 Weiterführende Konzepte
• A Bibliografie
• B Laufzeitexperimente Parallele Streams
• Index
• Fußnoten