[모던 자바 인 액션] 람다 표현식

필요성

익명 클래스로 다양한 동작을 구현할 수 있지만, 만족할 만큼 코드가 깔끔하지는 않았다. 람다 표현식은 익명 클래스처럼 이름이 없는 함수이면서 메소드를 인수로 전달할 수 있으므로 람다 표현식이 익명 클래스를 대신할 수 있다.

 

람다란 무엇인가?

람다 표현식은 메소드로 전달할 수 있는 익명 함수를 단순화한 것이라고 할 수 있다. 람다 표현식에는 다음과 같은 특징이 있다.

• 익명 : 보통의 메소드와는 달리 이름이 없으므로 익명이라고 표현한다.
• 함수 : 람다는 메소드와는 달리 특정 클래스에 종속되지 않으므로 함수라고 부른다. 하지만, 메소드처럼 파라미터 리스트, 바디, 반환 형식, 가능한 예외 리스트를 포함한다.
• 전달 : 람다 표현식을 메소드 인수로 전달하거나 변수로 저장할 수 있다.
• 간결성 : 익명 클래스와는 달리 많은 자질구레한 코드를 구현할 필요가 없다.

 

람다는 화살표 좌측의 파라미터, 화살표, 화살표 우측의 바디로 이루어진다. 람다 표현식에는 return이 함축되어 있으므로 return을 명시하지 않아도 된다. 또한 여러 행의 문장을 포함할 수 있다.

(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

 

럄댜 표현식의 문법에는 두 가지 스타일이 있다.

• 표현식 스타일 : (parameter) -> expression
• 블록 스타일 : (parameter) -> { statement1; statement2; }

주의해야 할 것은 표현식 스타일에는 return이 함축되어 있지만, 블록 스타일에서는 함축되어 있지 않다. 따라서, 필요한 경우에는 명시적으로 return 문을 사용해야 한다.

 

어디에, 어떻게 람다를 사용할까?

함수형 인터페이스

함수형 인터페이스라는 문맥에서 람다 표현식을 사용할 수 있다. 함수형 인터페이스는 정확히 하나의 추상 메소드를 지정하는 인터페이스이다. 상속받던 아니던, 결과적으로는 하나의 추상 메소드만 가져야 한다. 함수형 인터페이스로 Comparator, Runnable 등이 있다. 

 

람다 표현식으로 함수형 인터페이스의 추상 메소드를 직접 전달할 수 있으므로, 전체 표현식을 함수형 인터페이스를 구현한 클래스의 인스턴스로 취급할 수 있다.

 

함수 디스크립터

함수형 인터페이스의 추상 메소드의 시그니처는 람다 표현식의 시그니처와 매치된다. 이 때, 함수형 인터페이스의 추상 메소드 시그니처를 함수 디스크립터라고 한다.

 

cf) 시그니처란 메소드 명과 파라미터 타입, 개수를 의미한다. 컴파일을 할 때, 메소드 시그니처를 기준으로 메소드를 분류한다. 

 

@FunctionalInterface

함수형 인터페이스를 가리키는 어노테이션이다. 이 어노테이션으로 인터페이스를 선언했지만, 함수형 인터페이스, 즉 하나의 추상 메소드만 가지고 있지 않다면, 컴파일 에러를 발생시킨다.

 

람다 활용 : 실행 어라운드 패턴

데이터베이스의 파일 처리 같은 자원을 처리할 때, 자원을 열고(설정), 처리, 자원을 닫는(정리) 순서로 이루어진다. 이 순서로 이루어진 코드들을 실행 어라운드 패턴이라고 한다.

 

아래 코드는 파일을 열고, 한 줄을 반환하고, 닫는 코드이다.

public String processFile() throws IOException {
    try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
        return br.readLine();
    }
}

 

하지만, 동작을 다르게 하고 싶다면, 파일을 열고 닫는 것은 유지한 채로 처리 부분을 바꿔야 한다.

@FunctionalInterface
public interface BufferedReaderProcessor {
    public String process(BufferedReader br) throws IOException;
}

public String processFile(BufferedReaderProcessor brp) throws IOException {
    try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
        return brp.process(br);
    }
}

String oneLine = processFile((BufferedReader br) -> br.readLine());
String twoLine = processFile((BufferedReader br) -> br.readLine() + br.readLine());

 

함수형 인터페이스 사용

함수형 인터페이스의 추상 메소드는 람다 표현식의 시그니처를 묘사하고, 함수형 인터페이스의 추상 메소드 시그니처를 함수 디스크립터라고 한다. 다양한 람다 표현식을 사용하려면, 다양한 함수형 인터페이스가 필요하다.

 

자바에서는 많은 함수형 인터페이스를 포함하고 있으며, 다음과 같다.

 

Predicate

Predicate<T> 인터페이스는 test라는 추상 메소드를 정의하며, test는 T 형식의 객체를 인수로 받아 불리언을 반환한다. 참 또는 거짓이라는 명제(predicate)의 결과를 얻기 위해 사용한다.

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;
}

List<String> nonEmptyList = filter(Arrays.asList("모던", "자바", "인", "액션"), (String s) -> !s.isEmpty());

 

Consumer

Consumer<T> 인터페이스는 accept라는 추상 메소드를 정의하며, accpet는 T 형식의 객체를 인수로 받아 void를 반환한다. 반환값 필요없이 단지 소비(consume)하기 위해 사용한다.

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

forEach(Arrays.asList("모던", "자바", "인", "액션"), (String s) -> System.out.println());

 

Function

Function<T, R> 인터페이스는 apply라는 메소드를 정의하며, 제너릭 형식 T를 인수로 받아서 제너릭 형식 R 객체를 반환한다.

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

List<Integer> l = map(Arrays.asList("모던", "자바", "인", "액션"), (String s) -> s.length());

 

기본형 특화

위의 세 함수형 인터페이스에서는 제네릭의 내부 구현 때문에 참조형만 사용할 수 있다. 그리고, 메소드를 사용하는 과정에서 박싱과 언박싱이 발생하게 되는데, 추가 비용이 소모된다. 

 

그래서 등장한 것이 IntPredicate, IntConsumer 같은 기본형 특화 인터페이스이다. 이 인터페이스를 사용하면, 박싱, 언박싱이 일어나지 않는다.

IntPredicate evenNumbers = (int i) -> i % 2 != 0;
Predicate<Integer> oddNumbers = (Integer i) -> i % 2 != 0;	// 박싱, 언박싱 발생

 

예외, 람다, 함수형 인터페이스의 관계

함수형 인터페이스는 확인된 예외를 던지는 동작을 허용하지 않는다. 즉, 예외를 던지는 람다 표현식을 만들려면 확인된 예외를 선언하는 함수형 인터페이스를 직접 정의하거나 람다를 try-catch 블록으로 감싸야 한다. 보통은 후자를 사용한다.

 

형식 검사, 형식 추론, 제약

람다 표현식 자체에는 람다가 어떤 함수형 인터페이스를 구현하는지의 정보가 포함되어 있지 않다. 람다 표현식을 더 제대로 이해하려면 람다의 실제 형식을 파악해야 한다.

 

형식 검사

람다가 사용되는 콘텍스트를 이용해서 람다의 형식을 추론할 수 있다. 콘텍스트란 람다가 전달될 메소드 파라미터나 람다가 할당되는 변수 등을 말한다. 그 콘텍스트에서 기대되는 람다 표현식의 형식을 대상 형식이라고 부른다.

 

같은 람다, 다른 함수형 인터페이스

대상 형식이라는 특징 때문에 같은 람다 표현식이더라도 호환되는 추상 메소드를 가진 다른 함수형 인터페이스로 사용될 수 있다. 예를 들어, Callable과 PriviledgedAction 인터페이스 모두 인수를 받지 않고, 제너릭 형식 T를 반환하는 추상 메소드를 가지고 있다.

 

특별한 void 호환 규칙

람다의 바디에 일반 표현식이 있으면, void를 반환하는 함수 디스크립터와 호환된다. 예를 들어, 표현식이 void가 아닌 값을 반환하여도 void를 반환하는 인터페이스의 추상 메소드와 호환된다.

 

형식 추론

자바 컴파일러는 람다 표현식이 사용된 콘텍스트를 이용해서 람다 표현식과 관련된 함수형 인터페이스를 추론한다. 즉, 무엇이 파라미터로 주어지고, 무엇으로 반환되어야 하는지 알 수 있으므로, 컴파일러는 람다의 시그니처도 추론할 수 있다. 따라서, 람다 문법에서 이를 생략할 수 있다.

 

Comparator<T>를 살펴보면, 다음과 같다.

int compare(T o1, T o2);

Comparator<Apple> c = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
Comparator<Apple> c =  (a1, a2) -> a1.getWeight().compareTo(a2.getWeight());

 

상황에 따라 명시적으로 형식을 포함하는 것이 좋을 때도 있고, 형식을 배제하는 것이 가독성을 향상시킬 때도 있다. 어떤 방법이 좋은지는 결정하기 나름이다.

 

지역 변수 사용

지금까지 살펴본 모든 람다 표현식은 인수를 자신의 바디 안에서만 사용했다. 하지만 람다 표현식에서는 익명 함수가 하는 것처럼 외부 지역 변수를 활용할 수도 있다. 이를 람다 캡처링이라고 부른다.

 

람다에서 지역 변수에 접근할 수 있다는 가정 하에, 람다가 스레드에서 실행된다면 변수를 할당한 스레드가 사라져서 변수 할당이 해제되었을 때 람다를 실행하는 스레드에서는 해당 변수에 접근하려 할 수 있다. 따라서 자바 구현에서는 원래 변수가 아니라 지역 변수의 복사본을 제공한다.

 

메소드 참조

메소드 참조를 이용하면 기존의 메소드 정의를 재활용해서 람다처럼 전달할 수 있다. 때로는 람다 표현식보다 메소드 참조를 사용하는 것이 더 가독성이 좋으며 자연스러울 수 있다.

inventory.sort(
        (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight())
);

inventory.sort(Comparator.comparing(Apple::getWeight));

메소드 참조는 클래스::메소드명의 형태로 이루어지며, 특정 메소드만을 호출하는 람다의 축약형이라고 생각할 수 있다. 실제로 호출하는 것은 아니므로 괄호는 필요없다.

 

메소드 참조를 새로운 기능이 아니라 하나의 메소드를 참조하는 람다를 편리하게 표현할 수 있는 문법으로 간주할 수 있다.

 

메소드 참조를 만드는 방법

1. 정적 메소드 참조 : 예를 들어 Integer의 parseInt 메소드는 Integer::parseInt로 표현할 수 있다.
2. 다양한 형식의 인스턴스 메소드 참조 : 예를 들어 String의 length 메소드는 String::length로 표현할 수 있다.
3. 기존 객체의 인스턴스 메소드 참조 : 예를 들어 Transaction 객체를 할당받은 expensiveTransaction 지역 변수가 있고, Transaction 객체에 getValue 메소드가 있다면, expensiveTransaction::getValue로 표현할 수 있다.

List<String> str = Arrays.asList("a", "b", "A", "B");
str.sort((s1, s2) -> s1.compareToIgnoreCase(s2));

List<String> str = Arrays.asList("a", "b", "A", "B");
str.sort(String::compareToIgnoreCase);

Function<String, Integer> stringToInteger = Integer::parseInt;
Integer apply = stringToInteger.apply("1234");

private boolean startsWithNumber(String string){
    return Character.isDigit(string.charAt(0));
}

Predicate<String> startsWithNumber = this::startsWithNumber;

 

생성자 참조

클래스명과 new 키워드를 이용해서 기존 생성자의 참조를 만들 수 있다. 이것은 정적 메소드의 참조를 만드는 방법과 비슷하다. 

Supplier<Apple> c1 = Apple::new;
Apple a1 = c1.get();

Supplier<Apple> c2 = () -> new Apple();
Apple a2 = c2.get();

Function<Integer, Apple> c3 = Apple::new;
Apple a3 = c3.apply(100);

Function<Integer, Apple> c4 = (weight) -> new Apple(weight);
Apple a4 = c4.apply(100);

public List<Apple> map(List<Integer> list, Function<Integer, Apple> f){
    List<Apple> result = new ArrayList<>();
    for (Integer i : list){
        result.add(f.apply(i));
    }
    return result;
}

List<Integer> weights = Arrays.asList(1, 2, 3, 4);
List<Apple> apples = map(weights, Apple::new);

 

생성자 파라미터가 하나일 땐, Function, 생성자가 파라미터가 두 개일 땐 BiFunction 인터페이스로 생성되지만, 세 개 이상의 인수를 가지는 생성자의 생성자 참조를 사용하려면, 제공하는 것이 없으므로 직접 만들어서 사용해야 한다.

 

람다 표현식을 조합할 수 있는 유용한 메소드

자바8 API의 몇몇 함수형 인터페이스는 다양한 유틸리티 메소드를 포함한다. 간단한 여러 개의 람다 표현식을 조합해서 복잡한 람다 표현식을 만들 수 있다.

 

Comparator 조합

역정렬

inventory.sort(Comparator.comparing(Apple::getWeight).reversed());

comparing도 Comparator<T>를 반환하고, reversed도 Comparator<T>를 반환한다.

 

Comparator 연결

inventory.sort(Comparator.comparing(Apple::getWeight)
                .thenComparing(Apple::getColor));

 

Predicate 조합

Predicate 인터페이스는 복잡한 프레디케이트를 만들 수 있도록 negate(부정), and, or 세 가지 메소드를 제공한다. 예를 들어 '빨간색이 아닌 사과'처럼 특정 프레디케이트를 반전시킬 때, negate 메소드를 사용한다.

Predicate<Apple> redApple = (Apple a1) -> a1.getColor().equals(Color.RED);
Predicate<Apple> notRedApple = redApple.negate();

 

빨갛고, 무거운 사과를 위한 Predicate는 다음과 같이 and로 사용하여 구현할 수 있다.

Predicate<Apple> redAndHeavyApple = redApple.and(apple -> apple.getWeight() > 100);

 

단순한 람다 표현식을 조합해서 복잡한 람다 표현식을 만들 수 있다는 것이 장점이다.

 

Function 조합

Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 10;
Function<Integer, Integer> h = f.andThen(g);
int result = h.apply(3);

위 결과는 h = g(f(x))이다.

 

Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 10;
Function<Integer, Integer> h = f.compose(g);
int result = h.apply(3);

위 결과는 h = f(g(x))이다.

 

'Predicate, Comparator, Function 모두 틀만 잡고, 실제 사용은 추상 메소드로 한다'