자바 기본서를 다시 읽다. 4 - 표준 API의 함수적 인터페이스

자바 8에서부터는 빈번하게 사용되는 함수적 인터페이스(Functional Interface)는 java.util.function 표준 API 패키지로 제공한다.

이 패키지에서 제공하는 함수적 인터페이스의 목적은 메소드 또는 생성자의 매개 타입으로 사용되어 람다식을 대입할 수 있게 함이다.

 

함수적 인터페이스는 크게 Consumer, Supplier, Function , Operator, Predicate로 나뉘는데 각각의 특징은 아래와 같다.

• Consumer
  : 매개값 O , 리턴값 X
• Supplier
  : 매개값 X, 리턴값 O
• Function
  : 매개값 -> 리턴값으로 타입 변환
• Operator
  : 매개값 -> 리턴값으로 값 연산
• Predicate
  : 매개값 -> true/false 리턴

 

Consumer 함수적 인터페이스

Consumer 함수적 인터페이스는 리턴값이 없이 매개값을 소비하는 accept() 메소드만 가지고 있다.

// #1. Consumer 함수적 인터페이스 호출
Consumer<String> consumer = t -> System.out.println("this language is " + t);
consumer.accept("java"); // #1.1 accept

// #2. 객체 T와 U를 받아서 소비하는 BiConsumer
BiConsumer<String, String> consumer1 = (t, u) -> System.out.println("Lan : " + t + " , ver : " + u);
consumer1.accept("java","8");

// #3. 객체 T와 int형을 받아서 소비
ObjIntConsumer<Driver> objIntConsumer = (t, i) -> System.out.println("class : " + t.getClass() + " , i :" + i);
objIntConsumer.accept(new Driver(),8);

 

 

Supplier 함수적 인터페이스

Supplier 함수적 인터페이스는 리턴값만 있어 getXXX() 메소드만 가진다.

IntSupplier intSupplier = () -> {
  int num = (int) ( Math.random() ) * 6 +1;
  return num;
};

System.out.println(intSupplier.getAsInt());

 

 

Function 함수적 인터페이스

Function 함수적 인터페이스는 applyXXX() 메소드만 가지고 있으며 이 메소드들은 매개값을 리턴값으로 타입 변환하는 역할을 한다.

public class Main {

    public static List<Student> list = Arrays.asList(
            new Student("홍길동", 90 , 91),
            new Student("신용권" , 100, 14)
    );

    public static double avg(ToIntFunction<Student> function){
        // #1. 인자를 Student 객체를 가지는 function 함수적 인터페이스로 받는다.
        int sum = 0 ;
        for(Student student : list){
            sum+= function.applyAsInt(student); // # 3. apply method 호출
        }
        double ave = (double) sum / list.size();
        return ave;
    }
    
    public static void main(String[] args){
        // # 2. 그렇기 때문에 람다식으로 s는 자동으로 Student객체를 참조
        System.out.println(avg(s-> s.getEnglishScore())); 
        System.out.println(avg(s-> s.getMathScore()));
    }
}

 

 

Operator 함수적 인터페이스

Operator 함수적 인터페이스는 Function과 동일하게 applyXXX()  메소드만 가지고 있다. 이 메소드들은 연산을 한다.

public class Main {

    private static int[] scores = {91, 92, 93};

    public static int maxOrMin(IntBinaryOperator operator){ 
        // # 1. 매개변수로 Operator 함수적 인터페이스를 받음
        int result = scores[0];
        for(int score : scores){
            // # 2. 두 숫자들간의 연산값은 알아서 구현해라
            result = operator.applyAsInt(result,score);
        }
        return result;
    }

    public static void main(String[] args){

        int max = maxOrMin( // #3. applyAsInt 로직 구현
                (a, b) -> {
                    if(a >= b) return a;
                    else return b;
                }
        );

        int min = maxOrMin(
                (a, b) -> {
                    if(a>b) return b;
                    else return a;
                }
        );

        System.out.println("max : " + max + " ,  min : " + min); // max : 93 ,  min : 91

    }
}

 

 

Predicate 함수적 인터페이스

Predicate 함수적 인터페이스는 매개 변수와 boolean리턴값을 가지는 testXXX() 메소드를 가진다.

public class Main {

    public static List<Student> list = Arrays.asList(
            new Student("홍길동", 90 , 91),
            new Student("신용권" , 100, 14)
    );

    public static double avg(Predicate<Student> function){
        // #1. 인자를 Student 객체를 가지는 predicate 함수적 인터페이스로 받는다.
        int sum = 0 ;
        for(Student student : list){
            // #2. test식은 호출부에서 구현해라
            if(function.test(student)) sum+= student.getEnglishScore(); // # 3. apply method 호출
        }
        double ave = (double) sum / list.size();
        return ave;
    }

    public static void main(String[] args){
        // # 3. test식 구현했다.
        System.out.println(avg(s-> s.getName().equals("신용권")));
    }
}

 

함수적 인터페이스의 더 다양한 예시는 아래의 블로그 링크를 참조하면 좋을 것 같다.

https://steady-coding.tistory.com/308

주요 함수적 인터페이스 (JAVA)