📌모던 자바 인 액션 Chapter 3. 람다 표현식

📖 3.6 메서드 참조

메서드 참조 : 기존의 메서드 정의를 재활용해서 람다처럼 전달 할 수 있게 함.
-> 람다 표현식보다 더 가독성이 좋다.

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


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

3.6.1 메서드 참조를 만드는 방법

1. 정적 메서드참조
   Integer의 parselnt 메서드 => Integer::parselnt

2. 다양한형식의 인스턴스 메서드참조
   String의 length 메서드 => String::length

3. 기존객체의 인스턴스 메서드참조
   Transaction 객체를 할당받은 expensiveTransaction 지역 변수가 있고,
   Transaction 객체에는 getValue 메서드 => expensiveTransaction::getValue

말로하면 어려우니 아래 그림을 보자

퀴즈 3-6

다음의 람다표현식과 일치하는 메서드참조를 구현하시오.

1. ToIntFunction<String> stringToInt = 
				(String s) -> Integer.parselnt(s);

2. BiPredicate<List<String>, String> contains = 
				(list, element) -> list.contains(element);

3. Predicate<String> startsWithNumber = 
				(String string) -> this.startsWithNumber(string);
    

정답

1. Function<String, Integer> stringToInteger = Integer::parselnt;
	-> 정적 메서드를 호출하는 람다 표현식

2. BiPredicate<List<String>, String> contains = List::contains;
	-> 첫번째 인수의 contains 메서드를 호출

3. Predicate<String> startsWithNumber = this::startsWithNumber;

3.6.2 생성자 참조

Classname::new로 만들 수 있다.

Supplier의 () -> Apple과 같은 시그니처를 갖는 생성자가 있다고 가정하자.

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

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

Apple (integer weight)라는 시그니처를 갖는 생성자는 Function<T,U> 인터페이스의 시그니처와 같다. 따라서 다음과 같은 코드를 구현할 수 있다.

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

Function<Integer, Apple> c2 = (weight) -> new Apple(weight); 
Apple a2 = c2.apply(110);


// 예시
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;
}

Apple (String color, Integer weight) 처럼 두 인수를 갖는 생성자는 BiFunction 인터페이스와 같은 시그니처를 가지므로 다음과 같이 할 수 있다.

BiFunction<Color, Integer, Apple> c3 = Apple::new;
Apple a3 = c3.apply(GREEN, 110);

BiFunction<String, Integer, Apple> c3 = 
			(color, weight) -> new Apple(color, weight); 
Apple a3 = c3.apply(GREEN, 110);


// 예시
static Map<String, 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()) 
    		.apply(weight);
}

퀴즈 3-7

Color(int, int, int) 처럼 인수가 3개인 생성자의 생성자 참조는?

정답
Color::new
-> 시그니처를 제공하는 함수형 인터페이스가 필요하다.

public interface TriFunction<T, U, V, R> {
	R apply(T t, U u, V v);
}


// 이와 같이 사용 할 수 있다.
TriFunction<Integer, Integer, Integer, Color> colorFactory = Color::new;

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

다양한 정렬 기법으로 정렬하는 문제를 해결해보자. 지금까지 배운 동작 파라미터화, 익명 클래스, 람다 표현식, 메서드 참조 등을 총동원한다.

3.7.1 1단계 : 코드 전달

sort는 다음과 같은 시그니처를 갖는다.

void sort(Comparator<? super E> c)

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

sort의 동작은 파라미터화되었다.
1단계는 다음과 같이 완성 할 수 있다.

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단계 : 익명 클래스 사용

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

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

추상 메서드의 시그니처(함수 디스크립터라 불림)는 람다 표현식의 시그니처를 정의한다. Comparator의 함수 디스크립터는 (T, T) -> int다.
우리는 사과를 사용할 것이므로 더 정확히는 (Apple, Apple) -> int로 표현할 수 있다.

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

// 다음과 같이 더 간단히 할 수 있다.
inventory.sort((a1, a2) -> a1.getWeight().compareTo(a2.getWeight()))；



// 찐찐막 간단히는?
Comparator<Apple> c = Comparator.comparing((Apple a) -> a.getWeight());

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

// comparing(이 메서드가 정적 메서드인 이유는 9장에서 설명함)
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }

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

간소, 깔끔

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

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

자바 8 API의 몇몇 함수형 인터페이스는 다양한 유틸리티 메서드를 포함한다. 예를 들어 Comparator, Function, Predicate 같은함수형 인터페이스는 람다 표현식을 조합할 수 있도록 유틸리티 메서드를 제공한다.
간단히 말해, 간단한 여러 개의 람다 표현식을 조합해서 복잡한 람다 표현식을 만들 수 있다는 것이다.
??? 함수형 인터페이스는 하나의 추상 메서드만 제공할텐데 어떻게 유틸리티 메서드를 제공한다는 것인가?
-> 해답은 디폴트 메서드(default method)에 있다. (자세한 내용은 9장에서 봅시당)

3.8.1 Comparator 조합

• 역정렬

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

• Comparator 연결

무게가 같은 두 사과과 존재한다면 어떻게 해야 할까?
-> 두번째 Comparator을 만들어서 연결해주자!

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

3.8.2 Predicate 조합

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

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

and 메서드를 이용해서 빨간색이면서 무거운사과를 선택하도록 두 람다를 조합 할 수 있다.

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

or을 이용해서 ‘빨간색이면서 무거운(150그램 이상) 사과 또는 그냥 녹색 사과’
등 다양한 조건을 만들수 있다.

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

3.8.3 Function 조합

andThen, compose 두 가지 디폴트 메서드를 제공한다.

• andThen

Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2; 
Function<Integer, Integer> h = f.andThen(g); 
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))또는 (f ∘ g)(x) 라고표현
int result = h.apply(1); // 3을 반환

참고자료)
본 포스트는 모던 자바 인 액션 책을 참고하여 작성하였습니다.