🦊 chap3. 람다 표현식

3.1 람다란 무엇인가?

람다 표현식은 메서드로 전달할 수 있는 익명 함수를 단순화한 것이다.

이름은 없지만, 파라미터 리스트, 바디, 반환 형식, 발생할 수 있는 예외 리스트는 가질 수 있다.

• 익명 : 이름이 없기 때문에 익명이다.
• 함수 : 특정 클래스에 종속되지 않기 때문에 메서드가 아닌 함수라고 부른다.
• 전달 : 람다 표현식을 인수로 전달하거나 변수로 저장할 수 있다.
• 간결성 : 익명 클래스처럼 많은 자질구레한 코드를 구현할 필요가 없다.

람다는 세 부분으로 이루어진다

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

• 파라미터 리스트 : (Apple a1, Apple a2)
• 화살표 : -> 파라미터 리스트와 바디를 구분한다
• 람다 바디 : a1.getWeight().compareTo(a2.getWeight());

다음은 자바 8에서 지원하는 유효한 람다 표현식 5가지이다.

(String s) -> s.length()

(Apple a) -> a.getWeight() > 150

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

() -> 42

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

자바 설계자는 이미 C#이나 스칼라 같은 비슷한 기능을 가진 다른 언어와 비슷한 문법을 자바에 적용하기로 했다.

다음은 표현식 스타일 람다이다.

(parameters) -> expression

다음은 블록 스타일 람다이다.

(parameters) -> { statements; }

다음은 람다의 사용 예시이다.

불리언 표현식	(List list) → list.isEmpty()
객체 생성	() → new Apple(10)
객체에서 소비	(Apple a) → { System.out.println(a.getWeight()); }
객체에서 선택/추출	(String s) → s.length()
두 값을 조합	(int a, int b) → a * b
두 객체 비교	(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

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

3.2.1 함수형 인터페이스

2장에서 만든 Predicate 인터페이스로 필터 메서드를 파라미터화 할 수 있었다.

바로 Predicate 가 함수형 인터페이스이다.

함수형 인터페이스는 정확히 하나의 추상 메서드를 지정하는 인터페이스이다.

public interface Comparator<T> {
	int compare(T o1, T o2);
}

public interface Runnable {
	void run();
}

public interface ActionListener extends EventListener {
	void actionPerformed(ActionEvent e);
}

public interface CallableV> {
	V call() throws Exception;
}

public interface PrivilegedAction<T> {
	T run();
}

람다 표현식으로 함수형 인터페이스의 추상 메서드 구현을 직접 전달할 수 있다.

즉 전체 표현식을 함수형 인터페이스의 인스턴스로 취급할 수 있다.

3.2.2 함수 디스크립터

함수형 인터페이스의 추상 메서드 시그니처는 람다 표현식의 시그니처를 가리킨다.

람다 표현식의 시그니처를 서술하는 메서드를 함수 디스크립터라고 부른다.

@FunctionalInterface 는 무엇인가?

이는 함수형 인터페이스임을 가리키는 어노테이션이다.

이를 이용하여 인터페이스를 선언했지만 실제로 함수형 인터페이스가 아니라면 컴파일 에러를 발생시킨다.

이 어노테이션이 있는 인터페이스는 추상 메서드가 단 한개 여야 한다.

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

DB 파일 처리와 같은 자원 처리는 순환 패턴으로 자원을 열고 처리한 다음 자원을 닫는 순서로 이루어진다.

즉 실제 자원을 처리하는 코드를 설정과 정리 두 과정이 둘러싸는 형태이다.

이를 실행 어라운드 패턴(Execute Around Pattern) 이라고 부른다.

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

3.3.1 1단계 : 동작 파라미터화를 기억하라

현재 코드는 한 번에 한 줄만 읽을 수 있다.

기존의 설정, 정리 과정은 재사용하고 내부 메서드만 다른 동작을 수행하도록 하려면?

processFile 의 동작을 파라미터화하면 된다.

람다를 이용하면 메서드에 동작을 전달할 수 있다.

만약 한 번에 두 행을 읽게 만드려면?

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

3.3.2 2단계 : 함수형 인터페이스를 이용해서 동작 전달

함수형 인터페이스 자리에 람다를 사용할 수 있다.

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

public String processFile(BufferedReaderProcessor p) throws IOException {

}

3.3.3 3단계 : 동작 실행

람다 표현식으로 함수형 인터페이스의 추상 메서드 구현을 직접 전달할 수 있으며 전달된 코드는 함수형 인터페이스의 인스턴스로 전달된 코드와 같은 방식으로 처리한다.

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

3.3.4 4단계 : 람다 전달

다음은 한 행을 처리하는 코드이다.

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

다음은 두 행을 처리하는 코드이다.

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

3.4 함수형 인터페이스 사용

함수형 인터페이스의 추상 메서드 시그니처를 함수 디스크립터라고 한다.

다양한 람다 표현식을 사용하려면 공통의 함수 디스크립터를 기술하는 함수형 인터페이스 집합이 필요하다.

이미 자바 API 는 Comparable, Runnable, Callable 등의 다양한 함수형 인터페이스를 포함한다.

자바 8에서는 java.util.function 패키지에 여러 새로운 함수형 인터페이스를 제공한다.

3.4.1 Predicate

java.util.function.Predicate<T> 인터페이스는 test 라는 추상 메서드를 정의하고

T 형식의 객체를 인수로 받아 boolean 을 반환한다.

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

3.4.2 Consumer

java.util.function.Predicate<T> 인터페이스는 T 객체를 받아서 void 를 반환하는 accept 라는 추상 메서드를 정의한다.

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

3.4.3 Function

java.util.function.Function<T, R> 인터페이스는 T 객체를 받아서 R 객체를 를 반환하는 apply 라는 추상 메서드를 정의한다.

입력을 출력으로 매핑하는 람다를 정의할 때 활용할 수 있다.

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

제네릭 파라미터는 참조형(Reference Type) 만 사용할 수 있다.

자바에서는 기본형과 참조형을 변환하는 박싱, 언박싱을 지원한다.

이 동작이 자동으로 이루어지는 오토 박싱이라는 기능도 지원한다.

하지만 이런 변환 과정은 비용이 소모된다.

박싱한 값은 기본형을 감싸는 Wrapper 이고 힙에 저장된다.

자바 8에서는 기본형을 입출력으로 사용하는 상황에서 오토박싱 동작을 피할 수 있도록 특별한 함수형 인터페이스를 제공한다.

다음 예제에서 IntPredicate 는 1000 이라는 값을 박싱하지 않지만, Predicate 는 1000이라는 값을 Integer 객체로 박싱한다.

public interface IntPredicate {
	boolean test(int t);
}

IntPredicate evenNubmers = (int i) -> i % 2 == 0;
evenNumbers.test(1000);

Predicate<Integer> oddNumbers = (Integer i) -> i % 2 != 0;
oddNumbers.test(1000);

함수형 인터페이스는 확인된 예외 (Checked Exception)을 던지는 동작을 허용하지 않는다.

즉 예외를 던지는 람다 표현식을 만들려면 확인된 예외를 선언하는 함수형 인터페이스를 직접 정의하거나 람다를 try/catch 블록으로 감싸야 한다.

예를 들어 Function<T, R> 형식의 함수형 인터페이스를 기대하는 API를 사용하고 있어 직접 함수형 인터페이스를 만들기 어렵다면,

Function<BufferedReader, String> f = (BufferedReader b) -> {
	try {
		return b.readLine();
	} catch (IOException e) {
		throw new RuntimeException(e);
	}
}

비검사 예외로 전환하여야 한다.

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

람다 표현식을 더 제대로 이해하려면 람다의 실제 형식을 파악해야 한다.

3.5.1 형식 검사

람다가 사용되는 context 를 이용해서 람다의 type 을 추론할 수 있다.

어떤 context 에서 기대되는 람다 표현식의 형식을 대상 형식(target type)이라고 부른다.

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

대상 형식이라는 특징으로 같은 람다 표현식이라도 호환되는 추상 메서드를 가진 다른 함수형 인터페이스로 사용될 수 있다.

다음 두 할당문은 모두 유효하다.

Callable<Integer> c = () -> 42;
PrivilegedAction<Integer> p = () -> 42;

3.5.3 형식 추론

자바 컴파일러는 대상 형식을 이용해서 함수 디스크립터를 알 수 있기 때문에 컴파일러가 람다의 시그니처도 추론할 수 있다.

컴파일러가 람다 표현식의 파라미터 타입에 접근할 수 있기 때문에 람다 문법에서는 이를 생략할 수 있다.

List<Apple> greenApples = filter(inventory, apple -> GREEN.equals(apple.getColor()));

// 형식 추론 x
Comparator<Apple> c = 
	(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

// 형식 추론
Comparator<Apple> c = 
	(a1, a2) -> a1.getWeight().compareTo(a2.getWeight());

3.5.4 지역 변수 사용

람다 표현식에서는 익명 함수처럼 자유 변수를 활용할 수 있고 이를 람다 캡처링이라고 부른다.

int portNumber = 1337;
Runnable r = () -> System.out.println(portNumber);

이를 위해서는 지역 변수는 명시적으로 final 로 선언되거나 재할당이 이루어지면 안된다.

다음은 컴파일할 수 없다.

int portNumber = 1337;
Runnable r = () -> System.out.println(portNumber);
portNumber = 31337;

인스턴스 변수는 힙에 저장되는 반면 지역 변수는 스택에 위치한다.

그렇기 때문에 자바 구현에서는 원래 변수에 접근을 허용하는게 아니라

자유 지역 변수의 복사본을 제공한다.

따라서 복사본의 값이 바뀌지 않아야 한다.

3.6 메서드 참조

메서드 참조를 이용하면 기존의 메서드 정의를 재활용해서 람다처럼 전달할 수 있다.

다음은 기존 코드다.

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

다음은 메서드 참조와 java.util.Comparator.comparing 을 활용한 코드다.

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

3.6.1 요약

메서드 참조는 특정 메서드만을 호출하는 람다의 축약형이라 할 수 있다.

메서드 참조를 이용하면 기존 메서드 구현으로 람다 표현식을 만들 수 있고, 명시적으로 메서드명을 참조함으로써 가독성을 높일 수 있다.

메서드 참조는 세 가지 유형으로 구분할 수 있다.

1. 정적 메서드 참조

Integer 의 parseInt 는 Integer::parseInt 로 표현할 수 있다.

1. 다양한 형식의 인스턴스 메서드 참조

String 의 length 는 String::length 로 표현할 수 있다.

1. 기존 객체의 인스턴스 메서드 참조

Transaction 객체를 할당받은 expensiveTransaction 지역 변수 인스턴스에서 Transaction 객체의 getValue 메서드를 호출하면 expensiveTransaction::getValue 로 표현할 수 있다.

3.6.2 생성자 참조

ClassName::new 처럼 클래스명과 new 키워드를 이용해서 기존 생성자의 참조를 만들 수 있다.

인수가 없는 생성자는 Supplier 를 이용할 수 있다.

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

Apple(Integer weight) 라는 시그니처를 갖는 생성자는 Function 을 이용할 수 있다.

Fuction<Integer, Apple> c1 = Apple::new;
Apple a2 = c2.apply(110);

Apple(String color, Integer weight 처럼 두 인수를 갖는 생성자는 BiFunction 을 이용한다.

Fuction<Color, Integer, Apple> c1 = Apple::new;
Apple a2 = c2.apply(GREEN, 110);

이를 이용하여 Map 으로 생성자와 문자열값을 관련시키고, String, Integer 가 주어졌을 때 다양한 무게를 갖는 여러 종류의 과일을 만드는 메서드를 정의할 수 있다.

static Map<Sring, Function<Integer, Fruit>> map = new HashMap<>();
static {
	map.put("apple", Apple::new);
	map.put("orange", Orange::new);
}

public static Fruit giveMeFruit(String fruit, Integer weight) {
	return map.get(fruit.toLowerCase()) // Function 반환
						.apply(weight);
}

3.7 람다, 메서드 참조 활용하기

3.7.1 1단계 : 코드 전달

void sort(Comparator<? super E> c)

이 코드는 Comparator 객체를 인수로 받아 두 사과를 비교한다.

객체 안에 동작을 포함시키는 방식으로 이제 sort 의 동작은 파라미터화 되었다고 할 수 있다.

public class AppleComparator implements Comparator<Apple> {
	public int compare(Apple a1, Apple a2) {
		return a1.getWeight().compareTo(a2.getWeight());
	}
}
inventory.sort(new AppleComparator());

3.7.2 2단계 : 익명 클래스 사용

한 번만 사용할 Comparator 를 구현하는 것 보다는 익명 클래스를 이용하자.

inventory.sort(new Comparator<Apple>() {
	public int compare(Apple a1, Apple a2) {
		return a1.getWeight().compareTo(a2.getWeight());
	}
}

3.7.3 3단계 : 람다 표현식 사용

자바 8에서는 람다 표현식이라는 경량화된 문법을 사용해 코드를 전달할 수 있다.

함수형 인터페이스를 기대하는 곳 어디에서나 람다 표현식을 사용할 수 있다.

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

자바 컴파일러는 람다 표현식이 사용된 context 를 사용해서 람다의 파라미터 type 을 추론한다.

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

Comparator 는 Comparable 키를 추출해서 Comparator 객체로 만드는 Function<> 을 인수로 받는 정적 메서드 comparing 을 포함한다. 이를 이용해 가독성을 향상하자

import static java.util.Comparator.comparing;

inventory.sort(comparing(apple -> apple.getWeight()));

3.7.4 4단계 : 메서드 참조 사용

메서드 참조를 이용하면 람다 표현시의 인수를 더 깔끔하게 전달할 수 있다.

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

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

자바 8 API의 몇몇 함수형 인터페이스는 다양한 유틸리티 메서드를 포함한다.

간단한 여러 개의 람다 표현식을 조합하여 복잡한 람다 표현식을 만들 수 있다.

함수형 인터페이스에서 추가로 메서드를 제공한다는 것 자체가 함수형 인터페이스의 정의에 어긋나는 것인데 어떻게 가능할까?

바로 디폴트 메서드이다.

3.8.1 Comparator 조합

Comparator<Apple> c = Comparator.comparing(Apple::getWeight);

• 역정렬

사과의 무게를 내림차순으로 정렬하고 싶다면 reversed 를 사용한다

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

• 연결

비교 결과를 더 다듬을 수 있는 두 번째 Comparator를 만들 수 있다.

thenComparing 은 첫 번째 비교자에서 두 객체가 같다고 판단되면 두 번째 비교자에 객체를 전달한다.

inventory.sort(comparing(Apple::getWeight)
				.reversed()
				.thenComparing(Apple::getCountry));

3.8.2 Predicate 조합

• 반전

특정 Predicate 의 결과를 반전시킬 때 negate 를 사용한다.

Predicate<Apple> notRedApple = redApple.negate();

• and

두 람다를 조합할 때 and 를 사용한다.

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

• or

두 람다를 조합할 때 or 을 사용한다.

Predicate<Apple> redAndHeavyAppleOrGreen = 
		redApple.and(apple -> apple.getWeight() > 150);
						.or(apple -> GREEN.equals(a.getColor()));

3.8.3 Function 조합

• andThen

주어진 함수를 먼저 적용한 결과를 다른 함수의 입력으로 전달한다.

Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2;
Function<Integer, Integer> h = f.andThen(g); // 수학적으로 g(f(x))
int result = h.apply(1); // 4를 반환

• compose

인수로 주어진 함수를 먼저 실행하고 외부 함수에 결과를 전달한다.

Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2;
Function<Integer, Integer> h = f.compose(g); // 수학적으로 f(g(x))
int result = h.apply(1); // 3을 반환