Java のデフォルトの関数インターフェイス-＆＃＆チュートリアル-php.cn

Java のデフォルトの関数インターフェイス

DDD

リリース： 2024-09-19 06:26:32

オリジナル

579 人が閲覧しました

Default Functional Interfaces in Java

Java のデフォルト関数インターフェースの学習が終わったので、それらをすべて共有したいと思いました!
関数型インターフェイスは、抽象メソッドを 1 つだけ持つインターフェイスです。ラムダ式 (関数型プログラミング) を扱う場合は、これらが必要です。これらはコードを簡素化し、ストリームで広く使用されています。独自の関数型インターフェースを作成することはできますが、Java が Consumer、Predicate、Function、Supplier などの重要なインターフェースを提供する場合、心配する必要はありません。

1. 消費者:

Consumer は、単一の入力引数を受け入れ、結果を返さない操作を表す関数インターフェイスです。通常、指定された引数を変更せずに、その引数に対するアクション (印刷やログ記録など) を実行するために使用されます。

署名: void accept(T t) (T はジェネリック型)

2. 述語:

Predicate は、ブール値を返す単一引数関数を表す関数インターフェイスです。これは、フィルタリングや条件の評価 (数値が偶数かどうかの確認など) によく使用されます。

署名: ブールテスト(T t)

3.機能:

Function は、1 つの引数を受け取り、結果を生成する関数を表す関数インターフェイスです。これは一般的に変換に使用されます (例: ある型を別の型に変換する、またはデータを変更する)。

署名: R apply(T t)

4. サプライヤー:

Supplier は、入力引数のない関数を表し、結果を返す関数インターフェイスです。これは、入力を必要とせずに値を生成または提供するためによく使用されます。

署名: T get()

Consumer、Predicate、Function、Supplier などの関数型インターフェイスを効果的に使用するには、通常、これらのインターフェイスをパラメーターとして受け入れる汎用メソッドを定義します。これにより、ジェネリックの力を活用し、メソッドがさまざまな型で動作できるようになります。

これらすべての機能を示す完全なコードの例を次に示します

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);
    }


}

ログイン後にコピー