Une question soudaine est que les expressions lambda de Kotlin sont plus faciles à écrire que les expressions lambda de Java. Qu'est-ce qui vous fait ressentir exactement cela? Je veux organiser mon esprit.
Une des façons d'écrire des fonctions anonymes. En Java, lors de la définition d'une fonction anonyme, elle a été décrite comme suit.
public class Main {
public static void main(String[] args) {
Runnable r = new Runnable(){
@Override
public void run() {
System.out.println("Hello lambda.");
}
};
r.run(); // Hello lambda.
}
}
À partir de Java8, les expressions lambda sont prises en charge, ce qui facilite leur expression.
public class Main {
public static void main(String[] args) {
Runnable r = () -> { System.out.println("Hello lambda."); };
r.run();
}
}
D'autre part, cela est exprimé par l'expression lambda de Kotlin comme suit.
public class Main {
fun main(args: Array<String>) {
val r = {print("Hello lambda")}
r()
}
}
Kotlin peut être omis si aucun argument n'est requis pour l'expression lambda, et qu'il existe des différences mineures telles que ne pas exiger le ";" à la fin de la ligne. Cela peut être exprimé presque de la même manière.
Prenons un autre exemple. Définissons une fonction calc qui reçoit deux valeurs numériques, applique une fonction qui les calcule et les renvoie. Cette fois de Kotlin
public class Main {
fun main(args: Array<String>) {
val op = { a:Int, b:Int -> a+b}
calc(1,2,op) // 3
}
fun calc(a: Int, b: Int, op: (Int, Int) -> Int): Int {
return op(a, b)
}
}
Vous pouvez l'écrire de la même manière qu'avant.
Alors que faire si vous voulez le définir de la même manière en Java?
. .. ... ....
Vous pouvez utiliser BiFunction, qui est une interface fonctionnelle.
import java.util.function.BiFunction;
public class Main {
public static void main(String[] args) {
BiFunction<Integer, Integer, Integer> op = (a, b) -> a+b;
calc(1, 2, op); // 3
}
public static Integer calc(Integer a, Integer b, BiFunction<Integer, Integer, Integer> op){
return op.apply(a,b);
}
}
Cependant, j'ai pu implémenter Javadoc sans rien regarder. N'est-ce pas? Je ne pourrais pas le mettre en œuvre sans enquêter. ..
Maintenant, implémentons quelque chose qui prend trois arguments et calcule. D'abord de Kotlin.
public class Main {
fun main(args: Array<String>) {
val op = { a:Int, b:Int, c:Int -> a+b+c}
calc(1,2,3,op) // 6
}
fun calc(a: Int, b: Int, c: Int, op: (Int, Int, Int) -> Int): Int {
return op(a, b)
}
}
Par rapport à la fois précédente, l'argument c a augmenté, mais j'ai pu l'écrire presque de la même manière que la dernière fois.
Mais qu'en est-il de Java? La dernière fois que j'ai utilisé BiFunction pour Java. Donc, je pense que vous devriez utiliser TriFunction avec la même colle. Mais ... *** Ce n'est pas fourni dans un package standard. *** ***
Par conséquent, vous devez définir vous-même l'interface du type de fonction (TriFunction), comme illustré dans l'exemple ci-dessous.
public class Main {
public static void main(String[] args) {
TriFunction<Integer, Integer, Integer, Integer> op = (a, b, c) -> a+b+c;
calc(1, 2, 3, op); //6
}
public static Integer calc(Integer a, Integer b, Integer c, TriFunction<Integer, Integer, Integer, Integer> op){
return op.apply(a,b,c);
}
@FunctionalInterface
interface TriFunction<A, B, C, R>{
R apply(A a, B b, C c);
}
}
Jusqu'à présent, nous avons comparé divers exemples. Alors résumons ce qui est différent.
Je comprends que la différence de facilité d'écriture entre les expressions lambda de Java et de Kotlin est "si la fonction peut être traitée comme une fonction de première classe".
Une fonction de première classe (anglais: fonction de première classe) [1] est la nature d'un langage de programmation qui peut traiter une fonction comme un objet de première classe, ou une telle fonction. C'est. Dans ce cas, la fonction a un type appelé type de fonction (en: type de fonction) dans un langage typé, et sa valeur devient un objet fonction ou autre. Plus précisément, il s'agit d'une fonction qui est générée lorsque le programme est exécuté, peut être incluse dans la structure de données et peut être transmise comme argument d'une autre fonction ou renvoyée comme valeur de retour.
Citation: https://ja.wikipedia.org/wiki/%E7%AC%AC%E4%B8%80%E7%B4%9A%E9%96%A2%E6%95%B0
Puisque les fonctions Kotlin sont des fonctions de première classe, vous pouvez définir des fonctions sans avoir besoin d'interfaces / classes à l'avance.
D'un autre côté, les fonctions Java ne sont pas des fonctions de première classe, elles nécessitent donc des interfaces ou des classes qui ne peuvent pas être gérées par les fonctions elles-mêmes et peuvent être utilisées comme conteneurs. Par conséquent, afin d'implémenter une fonction comme cette fois, il est nécessaire de vérifier l'interface en premier lieu, ou de la définir par vous-même si elle n'est pas préparée dans le package standard.
Je pense que cette différence est la différence dans le confort d'écriture de Lambda.
Cet article a été créé non pas pour dire que Java est mauvais, mais pour dissiper les vagues sentiments de brume. Après tout, si vous ne mâchez pas et ne vous organisez pas, votre compréhension ne s'approfondira pas. Je souhaite conserver cette attitude à l'avenir.
https://dogwood008.github.io/kotlin-web-site-ja/docs/reference/lambdas.html https://qiita.com/sano1202/items/64593e8e981e8d6439d3
Recommended Posts