[02] Lambda Expression

🏃 람다 표현식

람다 표현식은 익명 클래스(Anonymous Class)처럼 이름이 없는 함수면서 메서드를 인수로 전달할 수 있다. 람다 표현식에는 이름은 없지만, Parameter List, Body, Return Type, 발생할 수 있는 Exception List를 포함할 수 있다.

람다의 특징

• 익명
  - 보통의 메서드와 달리 이름이 없다.
• 함수
  - 메서드처럼 특정 클래스에 종속되지 않으므로 함수라 한다.
  - 메서드처럼 Parameter List, Body, Return Type, 가능한 Exception List를 포함한다.
• 전달
  - 람다 표현식을 메서드 인수로 전달하거나 변수로 저장할 수 있다.
• 간결성
  - 익명 클래스처럼 많은 코드를 구현할 필요가 없다.

-- 기존
Comparator<Apple> byWeight = new Comparator<Apple>() {
	public int compare(Apple a1, Apple a2) {
    	return a1.getWeight().compareTo(a2.getWeight());
    }
}

-- 람다 표현식
Comparator<Apple> byWeight = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

위 처럼 람다 표현식은 세 부분으로 구성된다.
1. 파라미터 리스트
2. 화살표
3. 람다 바디

---

🚁 함수형 인터페이스

함수형 인터페이스는 정확히 하나의 추상 메서드를 지정하는 인터페이스다. 함수형 인터페이스에는 @FunctionalInterface 어노테이션이 추가되어 있으며, 함수형 인터페이스임을 가리킨다.

자바 API의 함수형 인터페이스로 Predicate, Comparator, Runnable 등이 있다.

// java.util.function.Predicate
public interface Predicate<T> {
	boolean test(T t);
}

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

// java.lang.Runnable
public interface Runnable {
	void run();
}

// java.awt.event.ActionListener
public interface ActionListener extends EventListener {
	void actionPerformed(ActionEvent e);
}

// java.util.concurrent.Callable
public interface Callable<V> {
	V call() throws Exception;
}

// java.security.PrivilegedAction
public interface PrivilegedAction<T> {
	T run();
}

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

// 함수형 인터페이스 Runnable
Runnable r = () -> System.out.println("Hello World!");
r.run();

// 함수형 인터페이스 Callable
public Callable<String> fetch() {
	return () -> "Tricky example ;-)";
}
System.out.println(a1.fetch().call());

Function Descriptor

함수형 인터페이스의 추상 메서드 시그니처를 함수 디스크립터라고 한다. 다양한 람다 표현식을 사용하려면 공통의 함수 디스크립터를 기술하는 함수형 인터페이스 집합이 필요하다.

1) java.util.function.Predicate<T>

test라는 추상 메서드를 정의하며 제네릭 형식 T의 객체를 인수로 받아 boolean을 반환한다.

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

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

List<String> nonEmpty = filter(listOfStrings, (String s) -> !s.isEmpty());

2) java.util.function.Consumer<T>

accept라는 추상메서드를 정의하며 제네릭 형식 T의 객체를 인수로 받아 void를 반환한다.

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

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

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

3) java.util.function.Function<T, R>

apply라는 추상메서드를 정의하며 제네릭 형식 T의 객체를 인수로 받아서 제네릭 형식 R 객체를 반환한다.

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

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> list = map(Arrays.asList("lambdas", "in", "action"), (String s) -> s.length());

4) 특화된 형식의 함수형 인터페이스

자바의 모든 형식은 참조형 아니면 기본형에 해당하는데, 이전에 살펴본 세 개의 제네릭 함수형 인터페이스 Predicate<T>, Consumer<T>, Function<T, R>은 참조형만 사용할 수 있다. Java에서는 기본형과 참조형 간의 자동 변환 (Auto Boxing/Unboxing) 을 지원한다.

-- Auto Boxing : int (기본형) -> Integer (참조형)
List<Integer> list = new ArrayList<>();
for (int i=300; i<400; i++) {
	list.add(i);
}

하지만, 이러한 Boxing/Unboxing 과정에서 Boxing한 값은 기본형을 감싸는 Wrapper로써 Heap에 저장되어 메모리를 더 소비하며 기본형을 가져올 때도 메모리를 탐색한다. Java 8에서는 기본형을 입출력으로 사용하는 상황에서 Auto Boxing/Unboxing을 피할 수 있도록 특별한 형식의 함수형 인터페이스를 제공한다.

함수형 인터페이스	함수 디스크립터	boolean 특화	int 특화	long 특화	double 특화
Predicate<T>	T -> boolean		IntPredicate	LongPredicate	DoublePredicate
Consumer<T>	T -> void		IntConsumer	LongConsumer	DoubleConsumer
Function<T, R>	T -> R		IntFunction<R>	LongFunction<R>	DoubleFunction<R>
			IntToLongFunction	LongToIntFunction	DoubleToIntFunction
			IntToDoubleFunction	LongToDoubleFunction	DoubleToLongFunction
			ToIntFunction<T>	ToLongFunction<T>	ToDoubleFunction<T>
Supplier<T>	() -> T	BooleanSupplier	IntSupplier	LongSupplier	DoubleSupplier
UnaryOperator<T>	T -> T		IntUnaryOperator	LongUnaryOperator	DoubleUnaryOperator
BinaryOperator<T>	(T, T) -> T		IntBinaryOperator	LongBinaryOperator	DoubleBinaryOperator
BiPredicate<T, U>	(T, U) -> boolean
BiConsumer<T, U>	(T, U) -> void		ObjIntConsumer<T>	ObjLongConsumer<T>	ObjDoubleConsumer<T>
BiFunction<T, U, R>	(T, U) -> R		ToIntBiFunction<T, U>	ToLongBiFunction<T, U>	ToDoubleBiFunction<T, U>

@FunctionalInterface
public interface intPredicate {
	boolean test(int t);
}

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

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

5) 람다와 함수형 인터페이스

사용 사례	람다 예제	함수형 인터페이스
boolean 표현	(List<String> list) -> list.isEmpty()	Predicate<List<String>>
Object 생성	() -> new Apple(10)	Supplier<Apple>
Object 소비	(Apple a) -> System.out.println(a.getWeight())	Consumer<Apple>
Object 선택/추출	(String s) -> s.length	Function<String, Integer>
		ToIntFunction<String>
두 값 조합	(int a, int b) -> a * b	IntUnaryOperator
두 객체 비교	(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight())	Comparator<Apple>
		BiFunction<Apple, Apple, Integer>
		ToIntBiFunction<Apple, Apple>

---

📈 Execute Around Pattern

자원 처리에 사용하는 순환 패턴은 자원을 열고 (Open), 처리한 다음에 (Process), 자원을 닫는 (Close) 순서로 이루어진다. 이와 비슷하게 코드를 초기화/준비 하고 (init/ready), 작업을 수행한 다음에 (work), 정리/마무리 하는 (final) 패턴이다.

여기서 작업을 수행하는 work에 람다와 동작 파라미터화로 유연하고 간결한 코드를 구현할 수 있다.

-- 파일을 읽는 코드
-- 기존 방법 (동작 : 한 줄 읽기)
public String processFile() throws IOException {
	try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
		return br.readLine();
	}
}

-- 1단계 : 파일을 읽어서 처리하는 동작을 파라미터화 (함수형 인터페이스)
public interface BufferedReaderProcessor {
	String process(BufferedReader b) throws IOException;
}

-- 2단계 : 동작 전달 및 실행
public String processFile(BufferedReaderProcessor p) throws IOException {
	try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
		return p.process(br);
	}
}

-- 3단계 : 람다 표현식
String oneLine = processFile(br -> br.readLine());
String twoLine = processFile(br -> br.readLine() + "\r\n" + br.readLine());

---

👀 Method Reference

메서드 참조를 이용하면 기존의 메서드 정의를 재활용해서 람다처럼 전달할 수 있다. 메서드명 앞에 구분자(::)를 붙이는 방식으로 메서드 참조를 활용할 수 있다.

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

-- Method Reference : java.util.Comparator.comparing 활용
inventory.sort(comparing(Apple::getWeight));

메서드 참조의 3가지 유형

1) 정적 메서드 참조
- Ex) Integer.parseInt 메서드를 Integer::parseInt로 표현
2) 다양한 형식의 인스턴스 메서드 참조
- Ex) String의 length 메서드를 String::length로 표현
3) 기존 객체의 인스턴스 메서드 참조
- Ex) Apple 객체의 getColor 메서드를 Apple::getColor로 표현

생성자, 배열 생성자, super 호출 등에 사용할 수 있는 특별한 형식의 메서드 참조도 있다. List의 sort 메서드는 인수로 Comparator를 기대하며, Comparator는 (T, T) -> int 라는 함수 디스크립터를 갖는다.

-- 기존 : 대소문자 구별없이 정렬
List<String\> str = Arrays.asList("a", "b", "A", "B");
str.sort((s1, s2) -> s1.compareToIgnoreCase(s2));

-- Method Reference
str.sort(String::compareToIgnoreCase);

생성자 참조

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

-- 기존
Supplier<Apple> s = () -> new Apple();
Function<Integer, Apple> f = (weight) -> new Apple(weight);

-- 생성자 참조
Supplier<Apple> s = Apple::new;
Function<Integer, Apple> f = Apple::new;

Apple a1 = s.get();
Apple a2 = f.apply(100);

-- 심화 : 여러 객체 생성
List<Integer> weights = Arrays.asList(7, 3, 4, 10);
List<Apple> apples = map(weights, Apple::new);

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

---

🔩 람다 표현식 조합

Java 8 API의 함수형 인터페이스는 람다 표현식을 조합할 수 있는 유틸리티 메서드를 제공한다. 여러 개의 람다 표현식을 조합해서 복잡한 람다 표현식을 만들 수 있다.

Comparator 조합

1) comparing
비교에 사용할 키를 추출하는 Function 기반은 Comparator를 반환한다.

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

2) reversed
역순을 적용하는 Comparator를 반환한다.

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

3) thenComparing
이전 Comparator에 이어서 다음 Comparator를 전달한다.

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

Predicate 조합

1) negate
특정 Predicate를 반전시킨다.

-- 빨간 사과 Predicate
Predicate<Apple> redApple = e -> "RED".equals(e.getColor());

-- 빨간 사과가 아닌 Predicate
Predicate<Apple> notRedApple = redApple.negate();

2) and
And 조건으로 Predicate를 연결한다.

-- 빨간 색이면서 무거운 사과
Predicate<Apple> redAndHeavyApple = redApple.and(a -> a.getWeight() > 150);

3) or
Or 조건으로 Prdicate를 연결한다.

-- 빨간색이면서 무거운 사과 또는 녹색 사과
Predicate<Apple> redAndHeavyAppleOrGreenApple = 
	redApple
		.and(a -> a.getWeight() > 150)
		.or(a -> "GREEN".equals(a.getColor());

Function 조합

1) andThen
주어진 Function를 먼저 적용한 결과를 다른 Function의 입력으로 전달한다.

Function<String, String> addHeader = Letter::addHeader;
Function<String, String> transformationPipeline = 
	addHeader
		.andThen(Letter::checkSpelling)
		.andThen(Letter::addFooter);

2) compose
인수로 주어진 Function를 먼저 실행한 다음에 그 결과를 외부 Function의 인수로 전달한다.

---