Eine plötzliche Frage ist, dass Kotlins Lambda-Ausdrücke einfacher zu schreiben sind als Javas Lambda-Ausdrücke. Was genau lässt dich so fühlen? Ich möchte meinen Geist organisieren.
Eine Möglichkeit, anonyme Funktionen zu schreiben. In Java wurde beim Definieren einer anonymen Funktion Folgendes beschrieben.
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.
}
}
Ab Java8 werden Lambda-Ausdrücke unterstützt, was das Ausdrücken erleichtert.
public class Main {
public static void main(String[] args) {
Runnable r = () -> { System.out.println("Hello lambda."); };
r.run();
}
}
Andererseits wird dies durch Kotlins Lambda-Ausdruck wie folgt ausgedrückt.
public class Main {
fun main(args: Array<String>) {
val r = {print("Hello lambda")}
r()
}
}
Kotlin kann weggelassen werden, wenn für den Lambda-Ausdruck kein Argument erforderlich ist und es geringfügige Unterschiede gibt, z. B. dass das ";" am Ende der Zeile nicht erforderlich ist. Es kann fast genauso ausgedrückt werden.
Betrachten wir ein anderes Beispiel. Definieren wir eine Funktionsberechnung, die zwei numerische Werte empfängt, eine Funktion anwendet, die sie berechnet und zurückgibt. Diesmal aus 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)
}
}
Sie könnten es auf die gleiche Weise wie zuvor schreiben.
Was ist, wenn Sie es in Java genauso definieren möchten?
. .. ... ....
Sie können BiFunction verwenden, eine funktionale Schnittstelle.
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);
}
}
Ich konnte jedoch Javadoc implementieren, ohne etwas anzusehen. Oder nicht? Ich konnte es nicht implementieren, ohne es zu untersuchen. ..
Lassen Sie uns nun etwas implementieren, das drei Argumente akzeptiert und berechnet. Zuerst aus 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)
}
}
Im Vergleich zum vorherigen Mal hat das Argument c zugenommen, aber ich konnte es fast genauso schreiben wie beim letzten Mal.
Aber was ist mit Java? Das letzte Mal habe ich BiFunction für Java verwendet. Ich denke, Sie sollten TriFunction mit demselben Kleber verwenden. Aber ... *** Dies ist nicht in einem Standardpaket enthalten. *** ***
Daher müssen Sie die Funktionstypschnittstelle (TriFunction) selbst definieren, wie im folgenden Beispiel gezeigt.
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);
}
}
Bisher haben wir mit verschiedenen Beispielen verglichen. Fassen wir also zusammen, was anders ist.
Ich verstehe, dass der Unterschied in der einfachen Schreibweise zwischen Java und Kotlins Lambda-Ausdrücken darin besteht, "ob die Funktion als erstklassige Funktion behandelt werden kann".
Eine erstklassige Funktion (Englisch: erstklassige Funktion) [1] ist die Natur einer Programmiersprache, die eine Funktion als erstklassiges Objekt oder eine solche Funktion behandeln kann. Das ist. In diesem Fall hat die Funktion einen Typ namens Funktionstyp (en: Funktionstyp) in einer typisierten Sprache, und ihr Wert wird zu einem Funktionsobjekt oder dergleichen. Insbesondere handelt es sich um eine Funktion, die bei der Ausführung des Programms generiert wird, in die Datenstruktur aufgenommen und als Argument einer anderen Funktion übergeben oder als Rückgabewert zurückgegeben werden kann.
Zitat: https://ja.wikipedia.org/wiki/%E7%AC%AC%E4%B8%80%E7%B4%9A%E9%96%A2%E6%95%B0
Da Kotlin-Funktionen erstklassige Funktionen sind, können Sie Funktionen definieren, ohne dass zuvor Schnittstellen / Klassen erforderlich sind.
Andererseits sind Java-Funktionen keine erstklassigen Funktionen, daher benötigen sie Schnittstellen oder Klassen, die nicht von den Funktionen allein verarbeitet werden können und als Container verwendet werden können. Um eine Funktion wie diese zu implementieren, ist es daher erforderlich, die Schnittstelle zunächst zu überprüfen oder selbst zu definieren, wenn sie nicht im Standardpaket vorbereitet ist.
Ich denke, dieser Unterschied ist der Unterschied im Schreibkomfort von Lambda.
Dieser Artikel wurde erstellt, um nicht zu sagen, dass Java schlecht ist, sondern um die vagen Gefühle des Dunstes auszuräumen. Wenn Sie nicht kauen und sich organisieren, wird sich Ihr Verständnis schließlich nicht vertiefen. Ich möchte diese Einstellung auch in Zukunft beibehalten.
https://dogwood008.github.io/kotlin-web-site-ja/docs/reference/lambdas.html https://qiita.com/sano1202/items/64593e8e981e8d6439d3
Recommended Posts