API 명세서 뜯어보기 - Functional interface

Package

java.util.function

 

What is Functional Interface?

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

이것은 함수 인터페이스이므로 람다 식 또는 메소드 참조에 대한 할당 대상으로 사용할 수 있습니다.

 

Functional Interfaces

• Function<T, R>
• Predicate
• Consumer
• Supplier
• BiConsumer<T, U>
• BinaryOperator
• etc ...

 

Function<T, R>

• T - the type of the input to the function ( 함수의 매개변수 값의 타입 )
• R - the type of the result of the function ( 함수의 결과 값의 타입 )

Represents a function that accepts one argument and produces a result.

하나의 인수를 받아들이고 결과를 생성하는 함수를 나타냅니다.

Method

• accept(T t) : 주어진 매개변수에 대해 이 함수를 적용한다
• andThen(Function<? super R,? extends V> after) : 먼저 이 함수를 입력에 적용한 다음, 결과에 after 함수를 적용하는 구성된 함수를 반환합니다.
• compose(Function<? super V,? extends T> before) : 먼저 매개변수에 대해 before를 적용하고 결과에 대해서 이 함수를 적용하는 구성된 함수를 반환한다.
• indentity() : 항상 입력된 매개변수를 반환하는 함수를 반환한다.

Example

public void functionInterface(){
    Integer data = 10;

    Function<Integer, Integer> function = x -> x * 5;
    Function<Integer, Integer> andThenFunction = x -> x + 1;
    Function<Integer, Integer> composeFunction = x -> x - 1;

    System.out.println("apply() : " + function.apply(data));
    // 10 * 5 = 50

    int result = function.andThen(andThenFunction).apply(data);
    System.out.println("andThen() after : " + result);
    // 10 * 5 = 50 -> (after)50 + 1 = 51

    result = function.compose(composeFunction).apply(data);
    System.out.println("compose() before : " + result);
    // (before)10 - 1 = 9 -> 9 * 5 = 45

    result = function.compose(composeFunction).andThen(andThenFunction).apply(data);
    System.out.println("compose().andThen() : " + result);
    // (before)10 - 1 = 9 -> 9 * 5 = 45 -> (after)45 + 1 = 46

    System.out.println("--------------------------------------------");

    Function<Integer, Integer> identityFunction = Function.identity();
    System.out.println(identityFunction.apply(1));
    // input 1 -> Function<Integer, Integer> output 1

    System.out.println("--------------------------------------------");

    Function<Object, Object> identityFunction1 = Function.identity();
    Function<Object, Object> identityFunction2 = Function.identity();
    Function<Object, Object> identityFunction3 = Function.identity();
    Function<Object, Object> function1 = x -> x;
    Function<Object, Object> function2 = x -> x;
    Function<Object, Object> function3 = x -> x;

    System.out.println(identityFunction1);
    System.out.println(identityFunction2);
    System.out.println(identityFunction3);
    // instance ref == instance ref
    System.out.println(function1);
    System.out.println(function2);
    System.out.println(function3);
    // instance ref != instance ref

    System.out.println("--------------------------------------------");

    System.out.println(identityFunction1 == identityFunction2);
    System.out.println(identityFunction1 == identityFunction3);
    System.out.println(function1 == function2);
    System.out.println(function1 == function3);
}
/**
    apply() : 50
    andThen() after : 51
    compose() before : 45
    compose().andThen() : 46
    --------------------------------------------
    1
    --------------------------------------------
    java.util.function.Function$$Lambda$19/0x000000080009e440@64616ca2
    java.util.function.Function$$Lambda$19/0x000000080009e440@64616ca2
    java.util.function.Function$$Lambda$19/0x000000080009e440@64616ca2
    FunctionalInterface$$Lambda$20/0x000000080009e840@13fee20c
    FunctionalInterface$$Lambda$21/0x000000080009ec40@4e04a765
    FunctionalInterface$$Lambda$22/0x000000080009f040@783e6358
    --------------------------------------------
    true
    true
    false
    false
*/

 

---

Predicate

• T - the type of the input to the predicate ( 속성에 대한 입력 타입 )

Represents a predicate (boolean-valued function) of one argument.

매개변수 하나의 속성(boolean)을 나타낸다

This is a functional interface whose functional method is test(Object).

함수 메소드가 테스트(Object)인 함수 인터페이스 입니다.

Method

• test(T t) : 주어진 매개변수에 대해 이 속성을 평가합니다.
• and(Predicate<? super T> other> : 이 속성과 다른 속성의 단락 논리 AND를 나타내는 구성된 속성을 반환합니다.
• or(Predicate<? super T> other) : 이 속성과 다른 속성의 단락 논리 OR을 나타내는 구성된 속성을 반환합니다.
• not(Predicate<? super T> target) : 제공된 속성의 부정인 속성을 반환합니다.
• isEqual(Object targetRef) : 두 인수가 동일한지 테스트하는 속성을 반환합니다.
• negate() : 이 속성의 논리적 부정을 나타내는 속성을 반환합니다.

Example

public void predicateInterface(){
    List<Integer> list1 = new ArrayList<>();
    list1.add(1);
    list1.add(2);
    list1.add(3);

    List<Integer> list2 = new ArrayList<>();
    list2.add(3);
    list2.add(4);
    list2.add(5);

    Predicate<List<Integer>> predicate1 = x -> x.stream().anyMatch(y -> y == 1);
    Predicate<List<Integer>> predicate2 = x -> x.stream().anyMatch(y -> y == 3);
    Predicate<List<Integer>> predicate3 = x -> x.stream().anyMatch(y -> y == 6);
    boolean test = predicate1.test(list1);
    System.out.println("test : " + test);
    // predicate1( list1 ) -> true

    boolean test1 = predicate2.test(list1);
    System.out.println("test : " +test);
    // predicate2( list1 ) -> true

    boolean equal = Predicate.isEqual(predicate1).test(predicate2);
    System.out.println("equals : " + equal);
    // predicate2 == predicate1 -> false

    boolean not1 = Predicate.not(predicate1).test(list1);
    System.out.println("not : " + not1);
    // not(true) -> false

    boolean not2 = Predicate.not(predicate1).test(list2);
    System.out.println("not : " + not2);
    // not(false) -> true

    boolean test2 = predicate1.and(predicate2).test(list1);
    System.out.println("and : " + test2);
    // predicate1(list1) && predicate2(list1) -> true
    // predicate1 == anyMatch(1)(true) && predicate2 == anyMatch(3)(true)

    boolean test3 = predicate1.and(predicate2).test(list2);
    System.out.println("and : " + test3);
    // predicate1(list2) && predicate2(list2) -> false
    // predicate1 == anyMatch(1)(false) && predicate2 == anyMatch(3)(true)

    boolean test4 = predicate1.or(predicate2).test(list1);
    System.out.println("or : " + test4);
    // predicate1(list1) || predicate2(list1) -> true
    // predicate1 == anyMatch(1)(true) || predicate2 == anyMatch(3)(true)

    boolean test5 = predicate1.or(predicate2).test(list2);
    System.out.println("or : " + test5);
    // predicate1(list2) || predicate2(list2) -> true
    // predicate1 == anyMatch(1)(false) || predicate2 == anyMatch(3)(true)

    boolean test6 = predicate1.and(predicate2).or(predicate3).test(list1);
    System.out.println("and + or : " + test6);
    // predicate1(list1) && predicate2(list1) || predicate3(list1) -> true
    // predicate1 == anyMatch(1)(true) && predicate2 == anyMatch(3)(true)
    //          || predicate3 == anyMatch(6)(false)

    boolean test7 = Predicate.not(predicate1.and(predicate2).or(predicate3)).test(list1);
    System.out.println("not(and + or) : " + test7);
    // not(predicate1(list1) && predicate2(list1) || predicate3(list1)) -> false
    // not(predicate1 == anyMatch(1)(true) && predicate2 == anyMatch(3)(true)
    //          || predicate3 == anyMatch(6)(false))

    List<Integer> negateList = List.of(1,2,3,4,5,6,7,8,9,10);
    Predicate<Integer> negatePredicate = x -> x % 2 == 0;
    Predicate<Integer> negate = negatePredicate.negate();
    List<Integer> collect = negateList.stream().filter(negate).collect(Collectors.toList());
    System.out.println(collect);
    // negatelist = {1,2,3,4,5,6,7,8,9,10}
    // negatePredicate = {2,4,6,8,10}
    // negate = {1,3,5,7,9}
    // System.out.println(collect) = negate

}

/**
    test : true
    test : true
    equals : false
    not : false
    not : true
    and : true
    and : false
    or : true
    or : true
    and + or : true
    not(and + or) : false
    [1, 3, 5, 7, 9]
*/

 

---

Consumer

• T - the type of the input to the operation ( 작업에 대한 매개변수의 타입 )

Represents an operation that accepts a single input argument and returns no result. Unlike most other functional interfaces, Consumer is expected to operate via side-effects.

단일 입력 인수를 받아들이고 결과를 반환하지 않는 작업을 나타냅니다. 대부분의 다른 함수 인터페이스와 달리 Consumer는 부수적인 효과를 통해 작동할 것으로 예상됩니다.

This is a functional interface whose functional method is accept(Object).

이 함수 인터페이스는 accept(Object)인 함수 인터페이스 입니다.

Method

• accept(T t) : 주어진 인수에 대한 작업을 수행한다
• andThen(Consumer<? super T> after) : 이 작업과 이후 작업을 순서대로 수행하는 구성된 소비자를 반환합니다.
  • 이 작업을 수행할 때 예외가 발생하면 이후 작업이 수행되지 않습니다.

Example

public void consumerInterface(){
    List<Integer> list = new ArrayList<>();
    list.add(1); list.add(1);
    list.add(2); list.add(2);
    list.add(3); list.add(3);

    Consumer<List<Integer>> consumera = (x) ->{
        List<Integer> result = x.stream().filter(data -> data == 1).collect(Collectors.toList());
        for(Integer number : result)
            System.out.println("lambda : " + number);
    };

    Consumer<List<Integer>> consumerb = (y) ->{
        long count = y.stream().filter(data -> data == 1).count();
        System.out.println("consumerb : " + count);
    };

    consumera.andThen(consumerb).accept(list);
}

/**
    lambda : 1
    lambda : 1
    consumerb : 2
*/

 

---

Supplier

• T - the type of results supplied by this 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 get().|

이것은 함수 메소드가 get()인 함수 인터페이스 입니다.

Method

• get() : 결과를 가져옵니다.

Example

public void supplierInterface(){
    int i = 10;
    Supplier<Boolean> supplier = () -> i > 5;
    System.out.println(supplier.get());
        // default get()    

    Optional<Boolean> stream = Stream.generate(supplier).findAny();
    System.out.println(stream.get());
        // Stream.generate()
}
/**
    true
    true
*/

 

---

BiConsumer<T, U>

• T - the type of the first argument to the operation ( 작업에 대한 첫번째 매개변수의 타입 )
• U - the type of the second argument to the operation ( 작업에 대한 두번째 매개변수의 타입 )

Represents an operation that accepts two input arguments and returns no result. This is the two-arity specialization of Consumer. Unlike most other functional interfaces, BiConsumer is expected to operate via side-effects.

두 개의 매개변수와 결과를 반환하지 않는 작업을 나타낸다. 이것은 고객의 두 개의 매개변수의 전문화입니다. 대부분의 다른 함수 인터페이스와 달리 BiConsumer는 부수적인 효과를 통해 작동할 것으로 예상됩니다.

This is a functional interface whose functional method is accept(Object, Object).

이 함수 인터페이스는 accept(Object, Object)인 함수 인터페이스 입니다.

Method

• accept(T t, U u) : 주어진 인수에 대한 작업을 수행한다
• andThen(BiConsumer<? super T, ? super U> after) : 이 작업과 이후에 작업을 순서대로 수행하는 구성된 BiConsumer를 반환합니다.
  • 두 작업 중 하나를 수행 할 때 예외가 발생하면 구성된 작업의 호출자에게 전달되며 이 작업을 수행할 때 예외가 발생하면 이후 작업이 수행되지 않습니다.

Example

public void biConsumerInterface(){
        List<String> str1 = new ArrayList<>();
    str1.add("홍길동");
    str1.add("장보고");
    str1.add("유성룡");

    List<String> str2 = new ArrayList<>();
    str2.add("홍길동");
    str2.add("장보고");
    str2.add("이순신");

    BiConsumer<List<String>, List<String>> equals = (a, b) ->{
        if( a.size() != b.size() ) {
            System.out.println("false");
        } else {
            for(int i = 0; i < a.size(); i++){
                if( a.get(i).equals(b.get(i)) ){
                    System.out.println("true");
                } else {
                    System.out.println("false");
                }
            }
        }
    };

    BiConsumer<List<String>, List<String>> disp = (a, b) ->{
        a.stream().forEach(System.out::println);
    };

    equals.andThen(disp).andThen(disp).andThen(equals).accept(str1, str2);
}
/**
    true
    true
    false
    홍길동
    장보고
    유성룡
    홍길동
    장보고
    유성룡
    true
    true
    false
*/

 

---

BinaryOperator

• T - the type of the operands and result of the operator ( 피연산자의 타입과 연산의 결과 )

Represents an operation upon two operands of the same type, producing a result of the same type as the operands. This is a specialization of BiFunction for the case where the operands and the result are all of the same type.

동일한 유형의 두 피연산자에 대한 연산을 나타내며 피연산자와 동일한 유형의 결과를 생성합니다. 이것은 피연산자와 결과가 모두 같은 유형인 경우에 대한 BiFunction의 전문화입니다.

This is a functional interface whose functional method is BiFunction.apply(Object, Object).

이것은 함수 메소드가 BiFunction.apply(Object, Object)인 함수 인터페이스 입니다.

Method

• maxBy(Comparator<? super T> comparator) : 지정된 Comparator에 따라 두 요소 중 큰 요소를 반환하는 BinaryOperator를 반환합니다.
• minBy(Comparator<? super T> comparator) : 지정된 Comparator에 따라 두 요소 중 작은 쪽을 반환하는 BinaryOperator를 반환합니다.

Example

private void binaryOperator() {
    Comparator<Integer> integerComparator = (x, y) -> x.compareTo(y);
    BinaryOperator<Integer> integerBinaryOperator = BinaryOperator.maxBy(integerComparator);
    System.out.println(integerBinaryOperator.apply(1,5));
    // 5

    Comparator<String> stringComparator = (x, y) -> x.compareTo(y);
    BinaryOperator<String> stringBinaryOperator = BinaryOperator.minBy(stringComparator);
    System.out.println(stringBinaryOperator.apply("abc","def"));
    // abc

}
/**
    5
    abc
*/