Lambdas in Java

Lambdas in Java

Lambdas sind nicht deklarierte Funktionen, was bedeutet, dass sie zur Verwendung nicht explizit deklariert werden müssen. Es ist nicht erforderlich, einen Namen, Parameter, Zugriffsmodifikatoren oder Rückgabetyp anzugeben. Im Wesentlichen ist ein Lambda eine einfachere Möglichkeit, eine Schnittstelle mit einer einzigen Methode zu implementieren.

In Java lautet die grundlegende Syntax von Lambda-Funktionen:

(args) -> (body)

Beispiele

(int x, int y) -> { return x * y; }
Aluno display = (Pessoa p) -> { System.out.println(p.idade); }
() -> System.out.println(new Date());
() -> { return 25.789; }
x -> x 



<p>Geschweifte Klammern sind nur erforderlich, wenn der Funktionskörper mehr als eine Anweisung enthält. Zum Beispiel:<br>
</p>

<pre class="brush:php;toolbar:false">(int x, int y) -> { return x * y; }

Kann geschrieben werden als:

(int x, int y) -> return x * y;

Beide Formen führen zum gleichen Ergebnis.

Lambda-Funktionen können Parameter oder gar keine haben. Die Parametertypen können auch weggelassen werden, da Java ihre Typen ableitet.

Beispiele

1. Funktion mit Parametern (mit deklarierten Typen):

   (int x, int y) -> { return x * y; }

1. Funktion mit Parametern (ohne deklarierte Typen):

   (x, y) -> { return x * y; }

1. Funktion ohne Parameter:

   () -> System.out.println(new Date());

Wenn kein Rückgabeschlüsselwort verwendet wird, wird der Rückgabetyp der Funktion als void:
abgeleitet

(a) -> this.x = a;

Es ist wichtig zu beachten, dass sich Lambdas von anonymen Klassen unterscheiden. Dies kann in den generierten .class-Dateien beobachtet werden. Im Gegensatz zu anonymen Klassen generieren Lambdas nicht mehrere .class-Dateien für jede Verwendung.

---

Anwendungen von Lambdas in Java

Themen

Lambdas vereinfachen den Code, indem sie die Ausführlichkeit bei der Arbeit mit Threads reduzieren.

// Implementing the Runnable interface and creating a thread with it
Runnable e = new Runnable() {
    public void run() {
        System.out.println(new Date());
    }
};
new Thread(e).start();

// The same implementation using a lambda expression
Runnable e = () -> System.out.println(new Date());
new Thread(e).start();

// Even more concise
new Thread(
    () -> System.out.println(new Date())
).start();

---

Sammlungen

Lambdas vereinfachen Funktionen wie das Sortieren und Filtern in Sammlungen.

// Print all elements in a list
List<string> list = Arrays.asList("João", "Ana", "Maria", "Cesar");
for (String s : list) {
    System.out.println(s);
}

// Using lambdas
list.forEach(s -> System.out.println(s));

// Lambda with multiple statements
list.forEach(s -> {
    if (StringUtils.equals("Cesar", s)) {
        System.out.println(s);
    }
});

// Conventional sorting
Collections.sort(list, new Comparator<string>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
});
list.forEach(p -> System.out.println(p));

// Sorting using lambdas
Collections.sort(list, (String s1, String s2) -> s1.compareTo(s2));
list.forEach(p -> System.out.println(p));
</string></string>

---

Zuhörer

Lambdas vereinfachen den Code in Listenern, die das Observer-Entwurfsmuster implementieren.

// Listening to an action on a button in a Swing window
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Some actions...");
    }
});

// Using lambdas
button.addActionListener((e) -> {
    System.out.println("Some actions...");
});

---

Generische Funktionen

Lambdas können in generischen Funktionen verwendet werden, um Probleme zu lösen, indem Lambda-Ausdrücke als Parameter übergeben werden.

public class Main {
    /*
    * A method that tests a condition
    */
    public static void testExpression(List<string> list, Predicate<string> predicate) {
        list.forEach(n -> {
            if (predicate.test(n)) {
                System.out.println(n);
            }
        });
    }

    /*
    * Calling the method with a lambda
    */
    public static void main(String[] args) {
        List<string> list = Arrays.asList("João", "Ana", "Maria", "Cesar");
        // Prints "Cesar" if it exists
        testExpression(list, (n) -> StringUtils.equals("Cesar", n));
        // Prints the entire list
        testExpression(list, (n) -> true);
        // Prints nothing
        testExpression(list, (n) -> false);
    }
}
</string></string></string>

Das obige ist der detaillierte Inhalt vonLambdas in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!