Lassen Sie uns über funktionale Schnittstellen sprechen. Schauen Sie sich plötzlich den folgenden Code an.
Func.java
interface Foo {
public Function<String,String> doIt(Function<Integer,String> f);
}
Main.java
Foo foo = f -> x -> "ABC" + f.apply(x.length());
System.out.println(foo.doIt(x -> x + "$").apply("DEF"));
Dies ist ein Lambda-Ausdruck. Kehren wir zu den Grundlagen der Lambda-Ausdrücke zurück und schreiben Sie "Main.java", ohne es wegzulassen.
Main.java
Foo foo =
(Function<Integer,String> f) ->
{return (String x) -> {return "ABC" + f.apply(x.length());};}
Es mag zu lang sein, um es zu verstehen, aber schauen wir uns diesen Teil an. Der Punkt ist -Welcher Lambda-Ausdruck definiert, welche funktionale Schnittstelle ・ Verstehen Sie den Rückgabewert zu einem bestimmten Zeitpunkt Ich denke, es gibt zwei Punkte. Ich werde mir dessen immer bewusst sein.
Der obige Code steht am Anfang
public Function<String,String> doit(Function<Integer,String> f)
Ist die Definition von.
Das Argument lautet also "Function <Integer, String>". Stellen Sie sicher, dass Sie diese Funktion noch nicht definiert haben.
Schauen wir uns als nächstes den Rückgabewert Function <String, String> an.
(String x) -> {return "ABC" + f.apply(x.length());}
Nimmt einen String-Typ als Argument und gibt einen String-Typ zurück. Hier wird die Verarbeitung der Rückgabewertfunktion definiert.
Die Definition von doIt und die Definition des Rückgabewerts von doIt wurden vorgenommen.
Als nächstes folgt die Definition des Arguments Function <Integer, String>.
Dies geschieht in der zweiten Zeile von Main.java.
foo.doIt(x -> x + "$").apply("DEF")
Das ist x-> x +" $ ".
Wenn Sie es wagen, es neu zu schreiben
foo.doIt((Integer x) -> {return x + "$";}).apply("DEF")
Es wird sein. Es nimmt einen Integer-Typ als Argument und gibt einen String-Typ zurück.
Nachdem wir jede Definition überprüft haben, werfen wir einen Blick auf den Wertefluss.
Zuerst wird "doIt ()" aufgerufen, wobei die Funktionsdefinition ("x-> x +" $ "") übergeben wird.
Es gibt dann eine andere Funktionsdefinition zurück (x->" ABC "+ f.apply (x.length ())).
Zum Zeitpunkt der Ausführung von doIt befindet sich der Wert noch in der Funktionsdefinition.
Ein konkreter Wert wird durch Ausführen von "apply (" DEF ")" generiert, der mit "doIt ()" verknüpft ist.
"DEF" wird an das Argument "Function <String, String>" übergeben, das von "doIt ()" zurückgegeben wird.
Wenn ich versuche, den Wert zu ersetzen,
"ABC" + f.apply("DEF".length())
Es bedeutet das.
Das Argument Function <Integer, String> f wird mit dem Integer-Typ" DEF ".length () ausgeführt.
"DEF".length() + "$"
Hier wird der String-Typ "3 $" zurückgegeben. Dann ist die Rückgabefunktion von "doIt ()"
"ABC" + "3$"
Und der Endwert ist "ABC3 $".
Ich habe versucht, das Lambda im Lambda zu erklären. Wenn Sie Meinungen oder Ergänzungen haben, danke.
Recommended Posts