[Java8] 자바에서 제공하는 함수형 인터페이스

Java가 기본으로 제공하는 함수형 인터페이스

자바에서 미리 정의해둔 자주 사용할만한 함수 인터페이스들이 java.lang.function 패키지에 있다.

주요 인터페이스를 살펴보자.

 

Function<T, R> :  R apply(T t)

T 타입을 받아서 R 타입을 리턴하는 함수 인터페이스

//익명 내부 클래스 버전
public class Plus10 implements Function<Integer, Integer> {

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

public class Result {
	public static void main(String[] args) {
    
    	Plus10 plus10 = new Plus10();
        System.out.println(plus10.apply(1));
    }
}

//람다식 버전
public class Result {
	public static void main(String[] args) {

        Function<Integer, Integer> plus10 = (i) -> i + 10;
        System.out.println(plus10.apply(1));
    }
}

 

함수 조합용 메소드

• andThen : 입력 값으로 앞에오는 함수에 먼저 적용하고, 그 결과 값을 의 함수에 입력 값으로 사용한다.
• compose : 입력 값으로 뒤에오는 함수에 먼저 적용하고, 그 결과 값을 앞의 함수에 입력 값으로 사용한다.

//람다식 버전
public class Result {
	public static void main(String[] args) {

        Function<Integer, Integer> plus10 = (i) -> i + 10;
        Function<Integer, Integer> multiply2 = (i) -> i * 2;
        
        System.out.println(plus10.compose(multiply2(3)));	//multiply2 -> plus10 : (3*2)+10 = 16
        System.out.println(plus10.andTnen(multiply2(3)));	//plus10 -> multiply2 : (3+10)*2 = 26
    }
}

 

BiFunction<T, U, R> : R apply(T t, U u)

Function 인터페이스와 비슷하게 두 개의 값(T, U)를 받아서 R 타입을 리턴하는 함수 인터페이스

 

Consumer<T> : void Accept(T t)

T 타입을 받아서 아무값도 리턴하지 않는 함수 인터페이스

//람다식 버전
public class Result {
	public static void main(String[] args) {

        Consumer<Integer> printT = (t) -> System.out.println(t);
        printT.accept(10);	//10 출력
    }
}

 

함수 조합용 메소드

• andThen

 

Supplier<T> : T get()

T 타입의 값을 제공하는 함수 인터페이스

//람다식 버전
public class Result {
	public static void main(String[] args) {

        Supplier<Integer> get10 = () -> 10;
        System.out.println(get10.get());	//10 출력
    }
}

 

Predicate<T> : boolean test(T t)

T 타입을 받아서 boolean을 리턴하는 함수 인터페이스

//람다식 버전
public class Result {
	public static void main(String[] args) {

        Predicate<Integer> isEven = (i) -> i % 2 == 0;
        System.out.println(isEven.test(2));	//true 출력
    }
}

 

함수 조합용 메소드

• And
• Or
• Negate

 

UnaryOperator<T> : Function<T, T>

Function<T, R>의 특수한 형태로, 입력값 하나를 받아서 동일한 타입을 리턴하는 함수 인터페이스

Function을 implements한 형태이기 때문에 Function의 andThen, compose등을 동일하게 사용할 수 있다.

//람다식 버전
public class Result {
	public static void main(String[] args) {

        Function<Integer, Integer> plus10 = (i) -> i + 10;	//입력, 출력 타입이 동일할 때
        UnaryOperator<Integer> plus10 = (i) -> i + 10;		//UnaryOperator를 사용하면 코드가 깔끔

    }
}

 

BinaryOperator<T> : BiFunction<T, T, T>

BiFunction<T, U, R>의 특수한 형태로, 동일한 타입의 입렵값 두개를 받아 리턴하는 함수 인터페이스

T, U, R 이 모두 같은 타입일 때 BinaryOperator 줄여서 쓸 수 있다.

---

이 포스팅은 더 자바, Java 8 강의를 수강하며 작성되었습니다.

더 자바, Java 8 강의 | 백기선 - 인프런