Parlons des interfaces fonctionnelles. Tout à coup, jetez un œil au code ci-dessous.
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"));
Ceci est une expression lambda.
Revenons aux bases des expressions lambda et écrivons Main.java sans l'omettre.
Main.java
Foo foo =
(Function<Integer,String> f) ->
{return (String x) -> {return "ABC" + f.apply(x.length());};}
Cela peut être trop long à comprendre, mais regardons cette partie. Le point est -Quelle expression lambda définit quelle interface fonctionnelle ・ Comprendre la valeur de retour à un moment donné Je pense qu'il y a deux points. Je serai donc toujours conscient de cela.
Le code ci-dessus est au début
public Function<String,String> doit(Function<Integer,String> f)
Est la définition de.
L'argument est donc «Function <Integer, String>». Assurez-vous que vous n'avez pas encore défini cette fonction.
Ensuite, regardons la valeur de retour Function <String, String>.
(String x) -> {return "ABC" + f.apply(x.length());}
Prend un type String comme argument et renvoie un type String. Le traitement de la valeur de retour Function est défini ici.
La définition de doIt et la définition de la valeur de retour de doIt ont été faites.
Vient ensuite la définition de l'argument «Function <Integer, String>».
Ceci est fait sur la deuxième ligne de Main.java.
foo.doIt(x -> x + "$").apply("DEF")
C'est x-> x +" $ ".
Si vous osez le réécrire
foo.doIt((Integer x) -> {return x + "$";}).apply("DEF")
Ce sera. Il prend un type Integer comme argument et renvoie un type String.
Maintenant que nous avons vérifié chaque définition, examinons le flux de valeurs.
Tout d'abord, doIt () est appelé, en passant la définition de la fonction (x-> x +" $ ").
Il renvoie ensuite une autre définition de fonction (x->" ABC "+ f.apply (x.length ())).
Au moment où doIt est exécuté, la valeur est toujours dans la définition de la fonction.
Une valeur concrète est créée en exécutant ʻapply ("DEF") , qui est lié à doIt ()`.
"DEF" est passé à l'argument de Function <String, String> renvoyé par doIt () `.
Quand j'essaye de remplacer la valeur,
"ABC" + f.apply("DEF".length())
Cela signifie que.
L'argument Function <Integer, String> f est exécuté en utilisant le type Integer de" DEF ".length ().
"DEF".length() + "$"
Ici, le type String «" 3 $ "» est retourné.
Ensuite, la fonction de retour de doIt () est
"ABC" + "3$"
Et la valeur finale est «" ABC3 $ "».
J'ai essayé d'expliquer le lambda dans le lambda. Si vous avez des opinions ou des suppléments, merci.
Recommended Posts