Äquivalent für Pythons Lambda-Funktionen in Java?

Question

Kann mir jemand sagen, ob es ein Äquivalent für Pythons Lambda-Funktionen in Java gibt?

Answer 1

Leider gibt es in Java bis zur Einführung von Java 8 keine Lambdas Lambda-Ausdrücke . Sie können jedoch erhalten fast den gleichen Effekt (auf wirklich hässliche Weise) mit anonymen Klassen:

interface MyLambda {
    void theFunc(); // here we define the interface for the function
}

public class Something {
    static void execute(MyLambda l) {
        l.theFunc(); // this class just wants to use the lambda for something
    }
}

public class Test {
    static void main(String[] args) {
        Something.execute(new MyLambda() { // here we create an anonymous class
            void theFunc() {               // implementing MyLambda
                System.out.println("Hello world!");
            }
        });
    }
}

Diese müssten natürlich in separaten Dateien gespeichert werden :(

Answer 2

Ich glaube nicht, dass es ein genaues Äquivalent gibt, aber es gibt anonyme Klassen, die dem am nächsten kommen. Aber immer noch ziemlich unterschiedlich. Joel Spolsky hat einen Artikel darüber geschrieben, wie die Schüler, die nur in Java unterrichtet werden, diese Schönheiten der funktionalen Programmierung verpassen: Kann Ihre Programmiersprache das auch? .

Answer 3

Eine Idee basiert auf einem generischen public interface Lambda<T> -- siehe http://www.javalobby.org/java/forums/t75427.html .

Answer 4

Ja,

Lambda-Ausdrücke werden in Java ab java8 eingeführt.

Die grundlegende Syntax für Lambda-Ausdrücke sind:

(parameters)->
{
  statements;
}

Beispiel

(String s)->
{
System.out.println(s);
}

Prüfen Sie diesen Link:

http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Answer 5

Wie bereits erwähnt, wurden die Lambda-Ausdrücke in Java 8 eingeführt.

Wenn Sie von Python, C# oder C++ kommen, sehen Sie sich die hervorragendes Beispiel von Adrian D. Finlay, das ich persönlich viel leichter verstehen konnte als die offizielle Dokumentation .

Hier ist ein kurzer Blick auf Adrians Beispiel, das mit einem Jupyter-Notebook mit dem Python-Kernel und IJava-Java-Kernel .

Python:

# lambda functions
add = lambda x, y : x + y
multiply = lambda x, y : x * y
# normal function. In python, this is also an object.
def add_and_print_inputs(x, y):
    print("add_and_print inputs : {} {}".format(x,y))
    return x + y
print(add(3,5), multiply(3,5), add_and_print_inputs(3,5))

Ausgabe:

add_and_print inputs : 3 5
8 15 8

Java-Lambda-Funktionen können mehrzeilig sein, während sie in Python aus einer einzigen Anweisung bestehen. Dies hat jedoch keinen Vorteil. In Python sind reguläre Funktionen ebenfalls Objekte. Sie können als Parameter zu jeder anderen Funktion hinzugefügt werden.

# function that takes a normal or lambda function (myfunc) as a parameter
def double_result(x,y,myfunc):
    return myfunc(x,y) * 2
double_result(3,5,add_and_print_inputs)

Ausgabe:

add_and_print inputs : 3 5
16

Java:

// functional interface with one method
interface MathOp{
    int binaryMathOp(int x, int y);
}
// lambda functions
MathOp add = (int x, int y) -> x + y;
MathOp multiply = (int x, int y) -> x * y;
// multiline lambda function
MathOp add_and_print_inputs = (int x, int y) -> {
    System.out.println("inputs : " + x + " " + y);
    return x + y;};// <- don't forget the semicolon
// usage
System.out.print("" +
add.binaryMathOp(3,5) + " " +
multiply.binaryMathOp(3,5) + " " + 
add_and_print_inputs.binaryMathOp(3,5))

Ausgabe:

inputs : 3 5
8 15 8

Und bei Verwendung als Parameter:

// function that takes a function as a parameter
int doubleResult(int x, int y, MathOp myfunc){
    return myfunc.binaryMathOp(x,y) * 2;
}
doubleResult(3,5,add_and_print_inputs)

Ausgabe:

inputs : 3 5
16