Antara Muka Fungsian Lalai dalam Java

Baru Selesai Mempelajari Antara Muka Fungsian Lalai di Java, saya terfikir untuk berkongsi kesemuanya!
Antara muka berfungsi ialah antara muka yang mempunyai hanya satu kaedah abstrak. Ia diperlukan jika anda akan berurusan dengan ungkapan lambda (pengaturcaraan berfungsi). Ia memudahkan kod dan digunakan secara meluas dalam strim. Walaupun anda boleh mencipta antara muka berfungsi anda sendiri, mengapa perlu risau apabila Java memberikan kami beberapa antara muka penting seperti Pengguna, Predikat, Fungsi dan Pembekal?

1. Pengguna:

Pengguna ialah antara muka berfungsi yang mewakili operasi yang menerima argumen input tunggal dan tidak mengembalikan hasil. Ia biasanya digunakan untuk melakukan tindakan pada hujah yang diberikan (seperti mencetak atau mengelog) tanpa mengubah suainya.

Tandatangan: batal terima(T t) (dengan T ialah jenis Generik)

2. Predikat:

Predikat ialah antara muka berfungsi yang mewakili satu fungsi hujah yang mengembalikan nilai boolean. Ia sering digunakan untuk menapis atau menilai keadaan (cth., menyemak sama ada nombor genap).

Tandatangan: ujian boolean(T t)

3. Fungsi:

Fungsi ialah antara muka berfungsi yang mewakili fungsi yang menerima satu hujah dan menghasilkan hasil. Ia biasanya digunakan untuk transformasi (cth., menukar satu jenis kepada yang lain atau mengubah suai data).

Tandatangan: R terpakai(T t)

4. Pembekal:

Pembekal ialah antara muka berfungsi yang mewakili fungsi tanpa argumen input dan mengembalikan hasil. Ia sering digunakan untuk menjana atau membekalkan nilai tanpa memerlukan input.

Tandatangan: T dapat()

Kami boleh menggunakan antara muka berfungsi dengan berkesan seperti Pengguna, Predikat, Fungsi dan Pembekal dengan biasanya mentakrifkan kaedah generik yang menerima antara muka ini sebagai parameter. Ini membolehkan kami memanfaatkan kuasa generik dan memastikan kaedah kami boleh berfungsi dengan pelbagai jenis.

Berikut ialah contoh kod lengkap yang menunjukkan kefungsian kesemuanya

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


}

Keputusan Akhir

Antara muka berfungsi dalam Java ialah alat yang berkuasa untuk memudahkan kod dan meningkatkan kebolehbacaan. Sama ada anda sedang memproses koleksi, melakukan transformasi atau mengendalikan aliran data, antara muka ini memudahkan untuk mentakrifkan operasi ringkas.

Dengan memahami dan menggunakan antara muka berfungsi seperti Pengguna, Predikat, Fungsi, Pembekal dan yang tersuai, anda boleh memanfaatkan sepenuhnya ciri pengaturcaraan berfungsi Java.

Atas ialah kandungan terperinci Antara Muka Fungsian Lalai dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!