Java의 기본 기능 인터페이스

방금 Java의 기본 기능 인터페이스에 대한 공부를 마치고 모두 공유하려고 생각했습니다!
기능적 인터페이스는 추상 메서드가 하나만 있는 인터페이스입니다. 람다 식(함수 프로그래밍)을 다루는 경우 필요합니다. 코드를 단순화하고 스트림에서 널리 사용됩니다. 자신만의 기능적 인터페이스를 만들 수 있지만 Java가 소비자, 조건자, 함수 및 공급자와 같은 몇 가지 중요한 인터페이스를 제공하는데 왜 걱정합니까?

1. 소비자:

Consumer는 단일 입력 인수를 받아들이고 결과를 반환하지 않는 작업을 나타내는 기능적 인터페이스입니다. 일반적으로 주어진 인수에 대해 수정하지 않고 작업(예: 인쇄 또는 로깅)을 수행하는 데 사용됩니다.

서명: void accept(T t)(여기서 T는 일반 유형)

2. 술어:

Predicate는 부울 값을 반환하는 단일 인수 함수를 나타내는 기능적 인터페이스입니다. 조건을 필터링하거나 평가하는 데 자주 사용됩니다(예: 숫자가 짝수인지 확인).

서명: 부울 테스트(T t)

3. 기능:

함수는 하나의 인수를 받아 결과를 생성하는 함수를 나타내는 함수형 인터페이스입니다. 일반적으로 변환(예: 한 유형을 다른 유형으로 변환 또는 데이터 수정)에 사용됩니다.

서명 : R 신청(T t)

4. 공급업체:

Supplier는 입력 인수가 없는 함수를 나타내고 결과를 반환하는 기능적 인터페이스입니다. 입력 없이 값을 생성하거나 제공하는 데 자주 사용됩니다.

서명: T get()

소비자, 조건자, 함수, 공급자와 같은 기능적 인터페이스를 일반적으로 매개변수로 받아들이는 일반 메서드를 정의하여 효과적으로 사용할 수 있습니다. 이를 통해 우리는 제네릭의 힘을 활용하고 우리의 방법이 다양한 유형에서 작동할 수 있도록 보장할 수 있습니다.

다음은 모든 기능을 보여주는 전체 코드의 예입니다

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


}

최종 평결

Java의 함수형 인터페이스는 코드를 단순화하고 가독성을 향상시키는 강력한 도구입니다. 컬렉션을 처리하든, 변환을 수행하든, 데이터 흐름을 처리하든 이러한 인터페이스를 사용하면 간결한 작업을 더 쉽게 정의할 수 있습니다.

Consumer, Predicate, Function, Supply, Custom 인터페이스와 같은 기능적 인터페이스를 이해하고 적용하면 Java의 기능적 프로그래밍 기능을 최대한 활용할 수 있습니다.

위 내용은 Java의 기본 기능 인터페이스의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!