[Java8] 자바에서 제공하는 함수형 인터페이스 람다식으로 사용방법

함수형 인터페이스는 추상메서드가 하나만 있는 인터페이스 이다. 자바에서는 이 함수형 인터페이스를 여러개 제공하는데 대표적인 함수형 인터페이스들을 사용해보자

 

Function<T,R>

Function<T,R>은 자바에서 제공하는 함수형 인터페이스 이다. T타입을 받아서 R타입을 리턴한다.

만약 <Integer, Integer> 이면 Integer 형 매개변수를 받아서 Integer형을 반환한다는 뜻이다.

람다식을 사용하지 않고 사용하려면 클래스에서 Function을 상속받아 사용해야 한다.

//Function<T,R> T 타입을 받아서 R 타입을 리턴하는 함수 인터페이스
public class Plus10 implements Function<Integer, Integer> {

    @Override
    public Integer apply(Integer integer) {
        return integer + 10;
    }

    public static void main(String[] args) {
        Plus10 plus10 = new Plus10();
        plus10.apply(1); //20
    }
}

람다식으로 구현하면 굳이 클래스에서 상속받아서 구현 할 필요가 없다.

람다는 (매개변수) - > {바디부} 로 이루어지며 {} 이 한줄이면 아래처럼 괄호를 생략해도 된다.

(매개변수) 명은 아무거나 해도 상관없다.

//람다식으로 구현
//매개변수(i) 명은 아무거나 해도 상관없다.
Function<Integer, Integer> plus10 = (i) -> i + 10;
plus10.apply(10); //20

함수를 조합할수 있는 메서드로 compose(함수), andThen(함수) 함수가 있다.

람다식으로 바디부에서 구현을 해서 사용해도 되고 아니면 함수에서 바로 사용해도 된다.

//함수를 조합할수 있는 메서드 compose(), andThen()
Function<Integer, Integer> plus10 = (i) -> i + 10;
Function<Integer, Integer> multiply2 = (i) -> i * 2;

Function<Integer, Integer> multiply2AndPlus10 = plus10.compose(multiply2);
multiply2AndPlus10.apply(2); //14

plus10.compose(multiply2).apply(2); //14
plus10.andThen(multiply2).apply(2); //24

plus10.compose(multiply2)를 하면 multiply2 함수가 먼저 적용된다음 plus10 함수가 적용된다.

plus10.andThen(multiply2)를 하면 plus10 함수가 적용된다음 multiply2 함수가 적용된다.

 

BiFuntion<T,U,R>

BiFunction<T,U,R>은 T,U 타입을 받아서 R 타입을 리턴한다.

BiFunction<Integer, Integer, Integer> plus = (i, j) -> i + j;
BiFunction<Integer, Integer, Integer> multiply = (i, j) -> i * j;
plus.apply(2, 4); //6
multiply.apply(2,4); //8

Consumer<T>

T타입을 받아서 아무값도 리턴하지 않는다.

//Consumer<T> T타입을 받아서 아무값도 리턴하지 않는 함수형 인터페이스
Consumer<String> print = (i) -> System.out.println(i);
print.accept("hello world"); //hello world 출력

Supplier<T>

T타입의 값을 제공한다.

//Supplier<T> T타입의 값을 제공하는 함수형 인터페이스
//람다식에서 ()안에 인자없이 함수구현
Supplier<Integer> get10 = () -> 10;
get10.get();

Predicate<T>

T타입을 받아서 Boolean을 리턴한다.

//Predicate<T> T타입을 받아서 Boolean을 리턴하는 함수형 인터페이스
Predicate<Integer> isEven = (i) -> i % 2 == 0;
Predicate<String> kangEqual = (i) -> i.equals("kang");
isEven.test(2); //true
kangEqual.test("kang"); //true

UnaryOperator<T>

Function<T,R>의 특수형태의 함수형 인터페이스이며 T,R이 같은 함수형 인터페이스일때 사용한다.

//UnaryOperator<T> Function<T,R> 함수형 인터페이스의 특수형태
//Function<Integer, Integer> 처럼 입력타입과, 결과타입이 같을때 UnaryOperator<Integer> 로 사용
UnaryOperator<Integer> plus20 = (i) -> i + 20;
System.out.println(plus20.apply(10)); //30

BinaryOperator<T>

BiFunction<T,U,R>의 특수형태의 함수형 인터페이스이며 T,U,R이 같은 함수형 인터페이스일때 사용한다.

//BinaryOperator<T> BiFunction<T,R,U> 함수형 인터페이스의 특수형태
//BiFunction<Integer, Integer, Integer> 첫번째, 두번째 입력타입과, 결과타입이 같을때 UnaryOperator<Integer> 로 사용
BinaryOperator<Integer> minus = (i, j) -> i - j;
System.out.println(minus.apply(10, 5)); //15

 

위에서 언급하지 않은 많은 함수형 인터페이스가 있다. 그건 아래 doc을 참고하자

https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html

 

백기선 더 자바, Java 8 : https://www.inflearn.com/course/the-java-java8/dashboard