Standardfunktionale Schnittstellen in Java

Ich habe gerade das Studium der Standard-Funktionsschnittstellen in Java abgeschlossen und dachte darüber nach, sie alle zu teilen!
Funktionale Schnittstellen sind Schnittstellen, die nur eine abstrakte Methode haben. Sie sind erforderlich, wenn Sie mit Lambda-Ausdrücken (funktionale Programmierung) arbeiten. Sie vereinfachen Code und werden häufig in Streams verwendet. Sie können zwar Ihre eigenen funktionalen Schnittstellen erstellen, aber warum sollten Sie sich Sorgen machen, wenn Java uns einige wichtige Schnittstellen wie Verbraucher, Prädikat, Funktion und Lieferant bereitstellt?

1. Verbraucher:

Consumer ist eine funktionale Schnittstelle, die eine Operation darstellt, die ein einzelnes Eingabeargument akzeptiert und kein Ergebnis zurückgibt. Es wird normalerweise verwendet, um eine Aktion für das angegebene Argument auszuführen (z. B. Drucken oder Protokollieren), ohne es zu ändern.

Signatur: void Accept(T t) (wobei T der generische Typ ist)

2. Prädikat:

Prädikat ist eine funktionale Schnittstelle, die eine einzelne Argumentfunktion darstellt, die einen booleschen Wert zurückgibt. Es wird oft zum Filtern oder Auswerten von Bedingungen verwendet (z. B. um zu prüfen, ob eine Zahl gerade ist).

Signatur: Boolescher Test(T t)

3. Funktion:

Funktion ist eine funktionale Schnittstelle, die eine Funktion darstellt, die ein Argument akzeptiert und ein Ergebnis erzeugt. Es wird häufig für Transformationen verwendet (z. B. Konvertieren eines Typs in einen anderen oder Ändern von Daten).

Unterschrift: R apply(T t)

4. Lieferant:

Supplier ist eine funktionale Schnittstelle, die eine Funktion ohne Eingabeargumente darstellt und ein Ergebnis zurückgibt. Es wird häufig zum Generieren oder Bereitstellen von Werten verwendet, ohne dass eine Eingabe erforderlich ist.

Signatur: T get()

Wir können funktionale Schnittstellen wie Verbraucher, Prädikat, Funktion und Lieferant effektiv nutzen, indem wir typischerweise generische Methoden definieren, die diese Schnittstellen als Parameter akzeptieren. Dadurch können wir die Leistungsfähigkeit von Generika nutzen und sicherstellen, dass unsere Methoden bei verschiedenen Typen funktionieren.

Hier ist ein Beispiel für den vollständigen Code, der die Funktionalität aller davon demonstriert

import java.util.List;
import java.util.Random;
import java.util.function.*;

public class Main {
    public static void main(String[] args) {
        // Consumer
        usingConsumer((a) -> System.out.printf("Hello %s", a), "saami");
        System.out.println();
        // Bi-Consumer
        usingBiConsumer((a, b) -> System.out.printf("Name: %s, Age: %d", a, b), "saami", 20);
        System.out.println();
        // Predicate
        var result1 = usingPredicate((a) -> a % 2 == 0, 34);

        if (result1) {
            System.out.println("Even");
        } else {
            System.out.println("Odd");
        }
        // Bi-Predicate
        var result2 = usingBiPredicate((a, b) -> a > b, 12, 22);
        if (result2) {
            System.out.println("Greater");
        } else {
            System.out.println("Lesser");
        }
        // Function
        var result3 = usingFunction((a) -> a + ": this is a number", 5);
        System.out.println(result3);

        // Bi-Function
        var result4 = usingBiFunction((a, b) -> (a > b ? "Greater": "Lesser"), 5, 6);
        System.out.println(result4);

        // Unary-Operator
        var result5 = usingUnaryOperator((a) -> a+5, 10);
        System.out.println(result5);

        // Binary-Operator
        var result6 = usingBinaryOperator((a, b) -> a + b, 12, 32);
        System.out.println(result6);
        Random r = new Random();


        // Function as Predicate
        var result7 = usingFunctionAsPredicate((a) -> a > 99, 999);
        System.out.println(result7);

        // Using Consumer for printing of the list.
        printData((a) -> {
            for (var ele : a) {
                System.out.println(ele);
            }
        } , List.of("S1", "S2", "S3", "S4", "S5"));

        // Using Supplier as a random number generator
        String[] arr = {"saami", "john", "raymond", "puff"};
        System.out.println(getRandomOne(arr, () -> new Random().nextInt(arr.length)));

        // Using Custom Comparator
        System.out.println(usingCustomFunctionalInterface((a, b, c) -> a + b + c, "Saami", " Abbas", " Khan"));

    }

    public static <T> void usingConsumer(Consumer<T> consumer, T a) {
        // Method that takes consumer interface will return void.
        // Can print something constituting 'a'
        consumer.accept(a);
    }

    public static <T, L> void usingBiConsumer(BiConsumer<T, L> biConsumer, T a, L b) {
        biConsumer.accept(a, b);
    }

    public static <T> boolean usingPredicate(Predicate<T> predicate, T a) {
        return predicate.test(a);
    }

    public static <T, L> boolean usingBiPredicate(BiPredicate<T, L> biPredicate, T a, L b) {
        return biPredicate.test(a, b);
    }

    public static <T, R> R usingFunction(Function<T, R> function, T a) {
//        T for the parameter and R for the return type here the return type could be as same as T or
//        could be different like if T is Integer the R could be String 8 + ""
        return function.apply(a);
    }

    public static <T, U, R> R usingBiFunction(BiFunction<T, U, R> biFunction, T a, U b) {
        return biFunction.apply(a, b);
    }

    public static <T> T usingUnaryOperator(UnaryOperator<T> unaryOperator, T a) {
        return unaryOperator.apply(a);
    }

    public static <T> T usingBinaryOperator(BinaryOperator<T> binaryOperator, T a, T b) {
        return binaryOperator.apply(a, b);
    }

    public static <T, R> R usingFunctionAsPredicate(Function<T, R> prediFunction, T a) {
        return prediFunction.apply(a);
    }

    public static <T> void printData(Consumer<T> consumer, T a) {
        /*
         * Prints the data, (List.of()) using a for loop inside of lambda function.
         */
        consumer.accept(a);
    }

    public static String getRandomOne(String[] arr, Supplier<Integer> supplier) {
        return arr[supplier.get()];
    }

    @FunctionalInterface
    interface Concat<T> {
        T concat(T a, T b, T c);
    }
    public static <T> T usingCustomFunctionalInterface(Concat<T> concat, T a, T b, T c) {
        return concat.concat(a, b, c);
    }


}

Endgültiges Urteil

Funktionale Schnittstellen in Java sind ein leistungsstarkes Werkzeug zur Vereinfachung von Code und zur Verbesserung der Lesbarkeit. Unabhängig davon, ob Sie Sammlungen verarbeiten, Transformationen durchführen oder den Datenfluss verwalten, erleichtern diese Schnittstellen die Definition prägnanter Vorgänge.

Durch das Verständnis und die Anwendung funktionaler Schnittstellen wie Verbraucher, Prädikat, Funktion, Lieferant und benutzerdefinierter Schnittstellen können Sie die funktionalen Programmierfunktionen von Java voll ausnutzen.

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