[JAVA] 함수형 인터페이스와 람다 - 자바에서 제공하는 함수형 인터페이스

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

 

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

• java.lang.function 패키지
• 자바에서 미리 정의해둔 자주 사용할만한 함수 인터페이스
• Function<T, R>
• BiFuncion<T, U, R>
• Consumer<T>
• Supplier<T>
• Predicate<T>
• UnaryPerator<T>
• BinaryOperator<T>

함수 인터페이스를 만들지 않고 자바에서 미리 정의해둔 함수를 가지고도 구현이 가능하다.

 

Function<T, R>

• T 타입을 받아서 R 타입을 리턴하는 함수 인터페이스
  • R apply(T t)

import java.util.function.Function;

public class Plus10 implements Function<Integer, Integer> {
    @Override
    public Integer apply(Integer integer) {
        return integer + 10;
    }
}

Plus10 plus10 = new Plus10();
plus10.apply(1);

 

람다를 이용한 방식

Function<Integer, Integer> plus = (i) -> i + 10;
plus.apply(1);

코드로 비교만 해도 람다가 훨씬 편함이 느껴진다.. (자바가 이렇게 좋았다고..)

• 함수 조합용 메소드
  • andThen - 먼저 선언한 계산식을 진행 후 andThen에 선언한 함수의 계산식 진행
  • compose - 연산자의 우선순위를 따라 간다 (곱하기, 나누기가 우선)

// andThen
Function<Integer, Integer> plus = (i) -> i + 10;
Function<Integer, Integer> multi = (i) -> i * 2;

System.out.println(plus.andThen(multi).apply(2)); // 결과값 24

// compose  
Function<Integer, Integer> plus = (i) -> i + 10;
Function<Integer, Integer> multi = (i) -> i * 2;

System.out.println(plus.compose(multi).apply(2)); // 결과값 16

---

BiFunction<T, U, R>

• 두 개의 값(T,U)을 받아서 R 타입을 리턴하는 함수 인터페이스
  • R apply(T t, U u)

BiFunction<Integer, Integer, Integer> plus1 = (integer, integer2) -> integer + integer2;
System.out.println(plus1.apply(1,2));	// 결과값 3

---

Consumer<T>

• T 타입을 받아서 아무값도 리턴하지 않는 함수 인터페이스
  • void Accept(T t)

Consumer<Integer> printT = (i) -> System.out.println(i);
printT.accept(10);

• 함수 조합용 메소드
  • andThen

    Consumer<Integer> printT = (i) -> System.out.println(i);
    Consumer<Integer> printL = (i) -> System.out.println(i);
    printT.andThen(printL).accept(2);
    // 결과값
    // 2
    // 2

---

Supplier<T>

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

Supplier<Integer> getNum = () -> 10;
System.out.println(getNum.get()); // 결과값 10

입력받는 값이 없으므로 () 괄호안에 아무것도 선언하지않음. 값만 리턴하는데 이걸 쓸일이 어디에 있는지는 아직 잘 모르겠다..

---

Predicate<T>

•  T 타입을 받아서 boolean을 리턴하는 함수 인터페이스
  •  boolean test(T t)

Predicate<String> startWith = (s) -> s.startsWith("jp");
System.out.println(startWith.test("jp")); // 결과값 true

•  함수 조합용 메소드
  •  And
  •  Or
  •  Negate

// and
Predicate<String> startWith = (s) -> s.startsWith("jp");
Predicate<String> endWith = (s) -> s.endsWith("good");

System.out.println(startWith.and(endWith).test("jp good"));	// 결과값 true

// or
Predicate<String> startWith = (s) -> s.startsWith("jp");
Predicate<String> endWith = (s) -> s.endsWith("good");

System.out.println(startWith.or(endWith).test("vp good")); // 결과값 true

or 의 경우 jp 가 아닌 vp 여서 false 이지만 good이란 글자가 true 이므로 or 조건에 만족하기 떄문에 true가 나옴

// negate
Predicate<String> startWith = (s) -> s.startsWith("jp");
Predicate<String> result = startWith.negate();

System.out.println(result.test("jp"));	// 결과값 false

negate는 true, false 의 반대값을 반환

---

UnaryOperator<T>

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

Function<Integer, Integer> plus = (i) -> i + 10;
UnaryOperator<Integer> uPlus = (i) -> i + 10;

입력값과 리턴값의 타입이 같다면 uPlus처럼 줄여서 사용 가능

---

BinaryOperator<T>

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

BiFunction<Integer, Integer, Integer> bPlus = (integer, integer2) -> integer + integer2;
BinaryOperator<Integer> boPlus = (integer, integer2) -> integer + integer2;

3개의 타입이 모두 같다면 줄여서 사용 가능

---

인프런 더 자바, Java8 백기선님 강의를 참고하여 정리한 내용입니다.