Swipe um das Menü anzuzeigen

Es ist an der Zeit, einen genaueren Blick darauf zu werfen, wie Lambdas in Java erstellt werden und welche Rolle funktionale Schnittstellen dabei spielen.

Eine funktionale Schnittstelle kann verwendet werden, um eine Aktion oder Operation darzustellen, die ausgeführt werden kann. Anstatt für eine einfache Aufgabe eine vollständige Klasse zu erstellen, kann eine Schnittstelle mit einer einzigen Methode definiert werden, die die Aktion beschreibt.

Beispiel einer funktionalen Schnittstelle:

@FunctionalInterface
public interface MyFunctionalInterface {
    void myMethod();  // The only abstract method
}

Die @FunctionalInterface-Annotation ist optional, unterstützt jedoch den Compiler und Entwickler dabei, sicherzustellen, dass die Schnittstelle weiterhin funktional bleibt und das Hinzufügen von mehreren abstrakten Methoden verhindert wird.

Warum werden sie benötigt?

In der Stream-API werden funktionale Schnittstellen verwendet, um verschiedene Verhaltensweisen an Methoden zu übergeben, die mit Datensammlungen arbeiten.

Beispielsweise kann eine Filterbedingung an eine Methode übergeben werden, die bestimmte Elemente aus einer Liste auswählt, oder eine Operation, um jedes Element zu transformieren, wie in Methoden wie filter() und map().

Main.java


              1234567891011121314151617
            
package com.example;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

        // Using `filter()` to extract even numbers
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(n -> n % 2 == 0)  // Predicate: keeps only even numbers
                                           .collect(Collectors.toList());
        System.out.println(evenNumbers);
    }
}

Die Methode filter() verwendet eine spezielle funktionale Schnittstelle namens Predicate<T> (die später behandelt wird), die prüft, ob ein Element eine bestimmte Bedingung erfüllt. In diesem Fall bestimmt der Lambda-Ausdruck n -> n % 2 == 0, ob eine Zahl gerade ist. Ist die Zahl ohne Rest durch 2 teilbar, bleibt sie im Stream.

Erstellen einer eigenen funktionalen Schnittstelle

Angenommen, es wird eine Schnittstelle benötigt, um arithmetische Operationen wie Addition oder Subtraktion auszuführen. Es kann eine funktionale Schnittstelle namens ArithmeticOperation mit einer Methode apply erstellt werden, die eine Operation auf zwei Zahlen, a und b, ausführt.

@FunctionalInterface
public interface ArithmeticOperation {
    int apply(int a, int b);  // Method to perform an operation on two numbers
}

Nachdem die Schnittstelle definiert ist, können Lambda-Ausdrücke verwendet werden, um verschiedene Operationen wie Addition und Subtraktion zu definieren:

Main.java


              1234567891011
            
public class Main {
    public static void main(String[] args) {
        // Addition
        ArithmeticOperation add = (a, b) -> a + b;
        System.out.println("Sum: " + add.apply(5, 3));  // 8

        // Subtraction
        ArithmeticOperation subtract = (a, b) -> a - b;
        System.out.println("Difference: " + subtract.apply(5, 3));  // 2
    }
}

Die Lambda-Ausdrücke (a, b) -> a + b und (a, b) -> a - b implementieren die Methode apply des Interfaces und führen jeweils Addition und Subtraktion aus. Der erste Lambda-Ausdruck gibt die Summe zweier Zahlen zurück, während der zweite deren Differenz liefert.

Dieser Ansatz bietet eine flexible Möglichkeit, verschiedene arithmetische Operationen zu verwenden, ohne für jede einzelne eigene Klassen erstellen zu müssen.