java8 함수식 인터페이스 - Function/Predict/Supplier/Consumer

Function

우리는 Java8의 가장 큰 특성이 함수식 인터페이스라는 것을 안다.@FunctionalInterface 주석이 표시된 모든 인터페이스는 함수식 인터페이스입니다. 구체적으로 말하면 이 주석이 표시된 모든 인터페이스는 lambda 표현식에 사용할 수 있습니다.

인터페이스 소개

/**
 * Represents a function that accepts one argument and produces a result.
 *
 * 
This is a functional interface
 * whose functional method is {@link #apply(Object)}.
 *
 * @param  the type of the input to the function
 * @param  the type of the result of the function
 *
 * @since 1.8
 */

위에서 설명한 바와 같이 Function에서 전달되는 두 가지 범주: T, R은 각각 입력 매개 변수 유형과 반환 매개 변수 유형을 대표한다.Function의 각 인터페이스는 다음과 같습니다.
인터페이스 1: 구체적인 내용 인터페이스 R apply(T t) 실행;
실례1: apply 사용

    //  
    Function version1 = new Function() {
        @Override
        public Integer apply(Integer integer) {
            return integer++;
        }
    };
    int result1 = version1.apply(20);


    // lamda 
    Function version2 = integer -> integer++;
    int result2 = version1.apply(20);
    

인터페이스 2:compose 이 방법은 기본 방법입니다. 이 방법은 하나의 function을 매개 변수로 수신하고 매개 변수 function가 실행한 결과를 매개 변수로 호출된 function으로 받아들여 두 function 조합의 기능을 실현합니다.

// compose  
default  Function compose(Function super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

실례2:compose 사용

public int compute(int a, Function function1, Function function2) {
    return function1.compose(function2).apply(a);
}

//  
test.compute(2, value -> value * 3, value -> value * value) 
//  ： 12 （ before）

인터페이스3: andThen은compose방법을 이해했다. 우리는andThen방법을 다시 보면 이해할 수 있다. 이름은'다음'이다. andThen방법도 하나의 function을 매개 변수로 받아들인다.compse와 달리 자체의 apply방법을 먼저 실행하고 실행 결과를 매개 변수의 function으로 한다.

public interface Function {
    default  Function andThen(Function super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
}

인스턴스 3: andThen 사용

public int compute2(int a, Function function1, Function function2) {
    return function1.andThen(function2).apply(a);
}

//  
test.compute2(2, value -> value * 3, value -> value * value) 
//   ： 36

반성: 여러 매개변수

Function 인터페이스는 간결하지만 Function 원본을 통해 알 수 있듯이 그는 매개 변수만 전달할 수 있고 실제 사용에서 수요를 만족시키지 못할 것이다.다음은 몇 가지 아이디어를 제공합니다.

BiFunction은 두 개의 매개 변수를 전달할 수 있다(Java8에서 다른 비슷한 Function도 제공)

포장류를 통해 해결한다

void 함수는 여전히 해결할 수 없습니다

매개 변수 때문에'자체 Function'함수는 업무상 복잡하고 변화가 많은 수요를 만족시킬 수 없기 때문에 Function 인터페이스를 사용자 정의합시다

@FunctionalInterface
    static interface ThiConsumer{
        void accept(T t, U u, W w);

        default ThiConsumer andThen(ThiConsumer super T,? super U,? super W> consumer){
            return (t, u, w)->{
                accept(t, u, w);
                consumer.accept(t, u, w);
            };
        }
    }

Function 인터페이스가 소개되었습니다.

단언적 인터페이스: Predicate

인터페이스 설명:

/**
 * Represents a predicate (boolean-valued function) of one argument.
 *
 * 
This is a functional interface
 * whose functional method is {@link #test(Object)}.
 *
 * @param  the type of the input to the predicate
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Predicate {

Predicate는 단언식 인터페이스입니다. 매개 변수는 매개 변수 T를 주고 boolean 형식의 결과를 되돌려줍니다.Function과 마찬가지로 Predicate의 구체적인 실현도 전송된 lambda 표현식에 따라 결정된다.
원본 코드는 더 이상 구체적으로 분석하지 않고 주로 test/and/or/negate 방법과 정적 방법인 isEqual이 있다. 구체적인 사용 실례는 다음과 같다.

    private static void testPredict() {
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
        List list = new ArrayList<>();
        for (int i : numbers) {
            list.add(i);
        }
        
        //  
        Predicate p1 = i -> i > 5;
        Predicate p2 = i -> i < 20;
        Predicate p3 = i -> i % 2 == 0;
        List test = list.stream()
                .filter(p1
                        .and(p2)
//                        .and(Predicate.isEqual(8))
                        .and(p3))
                .collect(Collectors.toList());
        System.out.println(test.toString());
        //print:[6, 8, 10, 12, 14]
    }

공급용 인터페이스: Supplier

인터페이스 소개

/**
 * Represents a supplier of results.
 *
 * 
There is no requirement that a new or distinct result be returned each
 * time the supplier is invoked.
 *
 * 
This is a functional interface
 * whose functional method is {@link #get()}.
 *
 * @param  the type of results supplied by this supplier
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Supplier 

인스턴스 사용:

        Supplier supplier = "Hello"::toLowerCase;
        System.out.println(supplier);

소비: Consumer

인터페이스 소개

/**
 * Represents an operation that accepts a single input argument and returns no
 * result. Unlike most other functional interfaces, {@code Consumer} is expected
 * to operate via side-effects.
 *
 * 
This is a functional interface
 * whose functional method is {@link #accept(Object)}.
 *
 * @param  the type of the input to the operation
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Consumer {

실제 사용

    NameInfo info = new NameInfo("abc", 123);
    Consumer consumer = t -> {
        String infoString = t.name + t.age;
        System.out.println("consumer process:" + infoString);
    };
    consumer.accept(info);

요약: 본고는 주로 Java8의 인터페이스 프로그래밍과 jdk에서 제공하는 네 가지 함수 인터페이스(FunctionalInterface)를 소개한다.Predict/Supplier/Consumer는 사실 Function의 변형이기 때문에 상세하게 소개하지 않았습니다.의문:FunctionalInterface 주석은 어떻게 lamada 표현식과 연결되고 함수 인터페이스는 컴파일할 때 어떻게 처리합니까?나중에 알아볼게요.