람다의 특징#

람다는 다른 메서드와 다르게 이름이 없으므로 익명이라고 하고, 메서드처럼 특정 클래스에 종속되지 않으므로 함수 라고 한다. 또한 람다 식의 결과를 변수에 저장하거나 다른 메서드의 파라미터로 전달이 가능하다.

사용 예시#

(String s) -> s.length(); 

파라미터로 String을 받고 s.length()의 결과인 int를 반환한다.

(int x, int y) -> {
    System.out.println("sum = ");
    System.out.println(x+y);
}

람다는 위의 예제처럼 2줄 이상의 행을 작성할 수 있다. 대신에 { } 안에 작성해야 한다.

() -> 42

파라미터가 없고 int 42를 반환한다.

람다 표현식 스타일#

(parameters) -> expression // 람다 표현식 스타일

(parameters) -> {statement;} // 블록 스타일

함수 디스크립터#

함수형 인터페이스의 추상 메서드의 시그니처는 람다 표현식의 시그니처를 가리킨다. 람다 표현식의 시그니처를 서술하는 메서드를 함수 디스크립터(function descriptor)라고 한다.

Runnable 인터페이스의 추상 메서드 run은 파라미터가 없고 void를 반환하므로, 파라미터와 void를 반환하는 시그니처로 생각할 수 있다. 이걸 () -> void 처럼 표현할 수 있다.

Predicate#

T -> boolean

Predicate<T> 인터페이스는 boolean test(T t)라는 추상 메서드를 정의하고 제너릭 타입 T를 파라미터로 받아 boolean를 반환한다. 제너릭 T 타입의 객체를 받아서 boolean 값(식)이 필요한 경우에 사용할 수 있다.

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

public <T> List<T> filter(List<T> list, Predicate<T> p) {
    List<T> result = new ArrayList<>();
    for(T t : list) {
        if(p.test(t)) {
            result.add(t);
        }
    }
    return result;
}

Predicate<String> p = (s) -> !s.isEmpty(); // 문자열이 비어 있지 않으면 true
List<String> list = filter(strList, p);

Consumer#

T -> ()

Consumer<T> 인터페이스는 T 객체를 받아서 void를 반환하는 accept(T t) 추상 메서드를 가지고 있다. T 형식의 객체를 파라미터로 받아서 어떤 특정한 동작을 정의하고 싶을 때 사용한다.

Integer 리스트를 받아서 각 Integer에 대해서 어떤 동작을 수행하는 메서드를 정의할 때 사용할 수 있다고 가정해보자.

@FunctionalList
public interface Consumer<T> {
    void accept(T t);
}

public <T> void forEach(List<T> list, Consumer<T> consumer) {
    for(T t : list) {
        consumer.accept(t);
    }
}

forEach(Arrays.asList(1,2,3,4,5), (Integer i) -> System.out.println(i));

위의 코드를 보면 (Integer i) -> System.out.println(i)에서 Consumer 인터페이스의 void accept(T t) 추상 메서드를 직접 구현하고 있다.

Function#

(T, R) -> R

Function<T, R> 인터페이스는 제너릭 T 타입의 객체를 받아 제너릭 R 타입으로 변환한 객체를 반환하는 R apply(T t) 추상 메서드를 가지고 있다. 입력을 출력으로 매핑하는 람다를 정의할 때 사용한다.

String을 받아 Integer 타입으로 바꾸는 메서드를 정의해보자.

@FunctionalInterface
public interface Function(T, R) {
    R apply(T t);
}

public <T, R> List<R> map(List<T> list, Function<T, R> function) {
    List<R> transferList = new ArrayList<>();
    for(T t : list) {
        transferList.add(function.apply(t));
    }
    
    return transferList;
}

List<Integer> newIntegerList = map(Arrays.asList("predicate", "consumer", "function"),
                                  	str -> str.length());

위의 코드에서 보면 map 메서드의 파라미터로 있는 Function 인터페이스의 apply를 str -> str.length() 람다식으로 표현하면서 구현하는 것을 볼 수 있다.

함수형 인터페이스와 람다 사용 예제#

형식 검사#

람다가 사용되는 상황을 이해해서 람다의 형식을 추론할 수 있다. 람다 식이 전달되는 메서드의 파라미터나 할당 되는 변수 타입을 봐서, 나올 것이라고 예상할 수 있는 람다식의 형식을 대상 형식이라고 한다.

List<Apple> selectApple = filter(bag, apple -> apple.getWeight() > 150);

위의 코드를 형식 검사를 해보자.

1. 람다가 사용된 상황은 무엇인가?

   • filter 메서드의 정의를 봐본다.

2. 확인을 해보니까 filter(List<Apple> bag, Predicate<Apple> p)이다.

   • 그렇다면 대상 형식으로 Predicate<Apple>이 나올 것으로 예상한다.

3. Predicate<Apple> 인터페이스를 확인해보니 boolean test(T t)의 추상 메서드를 가지고 있다.

   • 함수 디스크립터: Apple -> boolean

4. 함수의 디스크립터는 Apple -> boolean이고 람다식(apple.getWeight() > 150)의 시그니처(Apple -> boolean)과 똑같다.

5. 형식 검사 완료

   
   

void 호환 규칙#

람다 바디에 일반 표현식이 있으면 void를 반환하는 함수 디스크립터를 사용할 수 있다. 이때 파라미터 리스트 또한 동일해야 한다. List의 add 메서드는 Consumer<T>에 의해서 T -> void의 함수 디스크립터를 가지고 있지만, Predicate<T>의 boolean으로도 호환이 가능하다.

Consumer<String> con = str -> list.add(str);

// T -> ()은 T -> boolean 처럼 호환 가능, 이때 바디에 일반 표현식과 파라미터 리스트가 동일해야함
Predicate<String> pre = str -> list.add(str);

형식 추론#

람다 표현식이 사용된 대상 형식을 이용해서 람다 표현식과 관련된 함수형 인터페이스를 추론다. 그렇기 때문에 람다식의 시그니처도 추론할 수 있는 것이다.

int num = 1234;
Runnable r = () -> System.out.println(num);

람다 표현식에서는 람다 바디 말고 외부의 변수를 사용할 수 있는데, 이를 람다 캡처링이라고 한다.

람다는 인스턴스 변수와 정적 변수를 캡처할 수 있다. 하지만 이때 제약 조건이 있는데, final로 선언되어 있거나 final이 선언된 변수처럼 사용한 변수에 대해서 가능하다. 다시 말해 람다 표현식은 딱 한번만 할당할 수 있는 지역 변수만 쓸 수 있다는 것이다.

따라서 아래의 코드는 num을 2번 할당하기 때문에 사용할 수 없는 코드가 된다.

int num = 1234;
Runnable r = () -> System.out.println(num);
num = 2222;