Java - Allgemeine Fragen

Tech
1

Hellouu :blush:
Dann starten wir doch das Forum gleich mit den ersten technischen Fragen.

Mich interessiert schon länger die genaue Funktionalität und Anwendung von Lamdas in Java.
Was ich meine bis jetzt bereits verstanden zu haben ([Link][1]):

Lambdas ersetzen unnötig aufwendige/grosse „Anonymous Inner Classes“ (Klassen die man nur einmal braucht) oder „Functional Interfaces“ (Interface mit nur einer Methode).

Anonymous Inner Class

JButton testButton = new JButton("Test Button");
testButton.addActionListener(new ActionListener(){
@Override public void actionPerformed(ActionEvent ae){
    System.out.println("Click Detected by Anon Class");
  }
});

Functional Interfaces

package java.awt.event;
import java.util.EventListener;

public interface ActionListener extends EventListener {
    
public void actionPerformed(ActionEvent e);

}

Soweit so gut. Schwer tue ich mich aber jetzt mit der Schreibweise der Lamdas an sich:

//Examples:
(int x, int y) -> x + y
() -> 42
(String s) -> { System.out.println(s); }

Lamdas sind also eigentlich Funktionen, welche auch als Objekte abgespeichert werden können?
Habt ihr da einfache Anwendungsbeispiele, die ein bisschen weiterführen?

Viiielen Dank :smiley:
[1]: http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/Lambda-QuickStart/index.html

2

Lambdas sind Funktionsobjekte. Statt folgendes:

function int plusone(int x) {
    return x + 1;
}

Schreibst du dann einfach

(int x) -> x + 1

Die mathematische Schreibweise wäre folgendes:

f(x) = x + 1

Das ist es eigentlich schon :wink:

Funktionsobjekte kann man häufig brauchen, wenn man einer Funktion nicht nur Daten sondern auch Funktionalität übergeben wird. Eine bekannte Funktion aus funktionalen Programmiersprachen ist „map“. Dabei wird eine Funktion auf eine Liste von Daten angewendet.

Die Funktion von oben würde in Python so aussehen:

def plusone(x):
    return x + 1

Und als anonyme Funktion (=Lambdafunktion):

plusone = lambda x: x + 1

Wenn man den Datentyp von plusone in der REPL anschaut, sieht man auch, dass in Python Objekte den Typ „function“ haben können:

>>> type(lambda x: x + 1)
<class 'function'>

(Der Begriff Lambda kommt übrigens vom Lambdakalkül.)

Wenn man nun eine Liste von Daten hat, und man will die um je eins inkrementieren, kann man das mit map so machen:

items = [1, 2, 3]
results = map(lambda x: x + 1, items)

Man wendet also die Funktion lambda x: x + 1 (oder in Java-Schreibweise (int x) -> x + 1) auf jedes Element der Liste „items“ an. Eine Re-Implementation von map würde so aussehen:

def map(func, iterable):
    results = []
    for item in iterable:
        result = func(item)
        results.append(result)

results = map(plusone, [1, 2, 3])

Wenn man keine Funktionsobjekte hat ist sowas sehr mühsam. Viele Ansätze aus der funktionalen Programmierung werden mit Lambda-Funktionen erst gut möglich.

3

Dieses Video scheint mir gut zu sein:

4

Das hilft schon einiges zum grundlegenden Verständnis.
Danke - schaus mir an. :stuck_out_tongue: