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

6734 단어

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 표현식과 연결되고 함수 인터페이스는 컴파일할 때 어떻게 처리합니까?나중에 알아볼게요.

    좋은 웹페이지 즐겨찾기