🐹 chap3. 람다 표현식

3.1 람다란 무엇인가?

: 메서드로 전달할 수 있는 익명 함수를 단순화한 것

• 익명

  보통의 메서드와 달리 이름이 없으므로 익명이라 표현한다.

• 함수

  람다는 메서드처럼 특정 클래스에 종속되지 않으므로 함수라고 부른다. 하지만 메서드처럼 파라미터 리스트, 바디, 반환 형식, 가능한 예외 리스트를 포함한다.

• 전달

  람다 표현식을 메서드 인수로 전달하거나 변수로 저장할 수 있다.

• 간결성

  익명 클래스처럼 많은 자질구레한 코드를 구현할 필요가 없다.

예시) 커스텀 Comparator 객체를 기존보다 간단히 구현하기

• 기존 코드

    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());
  

[ 람다의 구조 ]

• 파라미터 리스트

  Comparator의 compare 메서드 파라미터(사과 두 개)

• 화살표

  화살표(->)는 람다의 파라미터 리스트와 바디를 구분한다.

• 람다 바디

  두 사과의 무게를 비교한다. 람다의 반환값에 해당하는 표현식이다.

[ 자바 8의 유효한 람다 표현식 예시 ]

• 표현식 스타일

    (parameters) -> expression
  

• 블록 스타일

    (parameters) -> { statements; }
  

• Quiz. 람다 문법

  람다 규칙에 맞지 않는 람다 표현식을 고르시오.

  1. ( ) → { }
  2. ( ) → “Raoul”
  3. ( ) → {return “Mario”;}
  4. (Integer i) → return “Alan” + i;
  5. (String s) → {”Iron Man”;}
     • 정답

     4번과 5번이 유효하지 않은 람다 표현식이다.

     1. 파라미터가 없으며 void를 반환하는 람다 표현식이다. 이는 public void run() {} 처럼 바디가 없는 메서드와 같다.
     2. 파라미터가 없으며 문자열을 반환하는 표현식이다.
     3. 파라미터가 없으며 (명시적으로 return 문을 이용해서) 문자열을 반환하는 표현식이다.
     4. return은 흐름 제어문이다. (Integer i) → {return “Alan” + i;}처럼 되어야 올바른 람다 표현식이다.
     5. “Iron Man”은 구문(statement)이 아니라 표현식(expression)이다. (String s) -> {return “Iron Man”;}처럼 명시적으로 return 문을 사용해야 한다.

[ 람다 예제와 사용 사례 ]

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

Comparator 형식 변수에 람다 할당

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

함수형 인터페이스에서 람다형 표현식을 사용할 수 있다.

3.2.1 함수형 인터페이스

Predicate 인터페이스로 필터 메서드를 파라미터화 했었는데, 이것이 바로 함수형 인터페이스이다.

Predicate는 **오직 하나의 추상 메서드만 지정**하기 때문이다.

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

함수형 인터페이스

정확히 하나의 추상 메서드를 지정하는 인터페이스

Comparator, Runnable 등이 있다.

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

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

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

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

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

• Quiz. 함수형 인터페이스

  다음 인터페이스 중 함수형 인터페이스는 어느 것인가?

    public interface Adder {
    		int add(int a, int b);
    }
      
    public interface SmartAdder extends Adder {
    		int add(double a, double b);
    }
      
    public interface Nothing {
    }
  

  • 정답

    Adder만 함수형 인터페이스이다.

    SmartAdder는 두 추상 add 메서드(하나는 Adder에서 상속받음)를 포함하므로 함수형 인터페이스가 아니다.

    Nothing은 추상 메서드가 없으므로 함수형 인터페이스가 아니다.

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

// 람다 사용
Runnable r1 = () -> System.out.println("Hello World 1");

// 익명 클래스 사용
Runnable r2 = new Runnable() {
		public void run() {
				System.out.println("Hello World 2");
		}
};

public static void process(Runnable r) {
		r.run();
}
process(r1); // 'Hello World 1' 출력
process(r2); // 'Hello World 2' 출력
// 직접 전달된 람다 표현식으로 'Hello World 3' 출력
process(() -> System.out.println("Hello World 3")); 

Runnable은 오직 하나의 추상 메서드 run을 정의하는 함수형 인터페이스이므로 올바른 코드다.

3.2.2 함수 디스크립터

: 람다 표현식의 시그니처(함수형 인터페이스의 추상 메서드 시그니처)를 서술하는 메서드

ex) Runnable 인터페이스의 유일한 추상 메서드 run은 인수와 반환값이 없으므로(void 반환) Runnable 인터페이스는 인수와 반환값이 없는 시그니처라고 생각할 수 있다.

public void process(Runnable r) {
		r.run();
}

process(() -> System.out.println("This is awesome!!"));

위 코드에서 () -> Systeml.out.println("This is awesome!!")은 인수가 없으며 void를 반환하는 람다 표현식으로 Runnable 인터페이스의 run 메서드 시그니처와 같다.

이때 한 개의 void 메서드 호출은 중괄호로 감쌀 필요가 없다.

• Quiz. 어디에 람다를 사용할 수 있는가?

  다음 중 람다 표현식을 올바르게 사용한 코드는?

    // 1번 코드
    execute((() -> {});
    public void execute(Runnable r) {
    		r.run();
    }
      
    // 2번 코드
    public Callable<String> fetch() {
    		return () -> "Tricky examplel ;-)";
    }
      
    // 3번 코드
    Predicate<Apple> p = (Apple a) -> a.getWeight();
  

  • 정답

    1번과 2번은 유효한 람다 표현식이다.

    첫 번째 예제에서 람다 표현식 ( ) -> { }의 시그니처는 ( ) -> void 이며 Runnable의 추상 메서드 run의 시그니처와 일치하므로 유효한 람다 표현식이다. 다만 람다의 바디가 비어있으므로 이 코드를 실행하면 아무 일도 일어나지 않는다.

    두 번째 예제도 유효한 람다 표현식이다. fetch 메서드의 반환 형식은 Callable이다. T를 String으로 대치했을 때 Callable 메서드의 시그니처는 ( ) -> String이 된다. ( ) -> “Tricky example ;-)”는 ( ) -> String 시그니처이므로 문맥상 유효한 람다 표현식이다.

    세 번째 예제에서 람다 표현식 (Apple a) -> a.getWeight()의 시그니처는 (Apple) -> Integer 이므로 Predicate : (Apple) -> boolean의 test 메서드의 시그니처와 일치하지 않는다. 따라서 유효한 람다 표현식이 아니다.

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

람다와 동작 파라미터화로 유연하고 간결한 코드를 구현하는 데 도움이 되는 예제에는 자원처리(ex. 데이터베이스의 파일 처리)가 있다.

순환 패턴으로 자원을 열고, 처리한 다음에, 자원을 닫는 순서로 이루어진다.

[ 실행 어라운드 패턴 ]

public String processFile() throws IOException {
		**try (BufferedReader br =
						new BufferedReader(new FileReader("data.txt")))** {
				return br.readLine(); // 실제 필요한 작업을 하는 행이다.
		}
}

굵은 글씨는 파일에서 한 행을 읽는 코드다.

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

위의 코드는 파일에서 한 번에 한 줄만 읽을 수 있다. 작업을 변경하려면 기존의 설정, 정리 과정은 재사용하고 processFile 메서드만 다른 동작을 수행하도록 하는 것이 좋을 것이다.

즉, processFile의 동작을 파라미터화하는 것이다.

람다를 이용해 동작을 전달한다. 다음은 BufferedReader에서 두 행을 출력하는 코드다.

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

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

함수형 인터페이스 자리에 람다를 사용할 수 있으므로, BufferedReader -> String과 IOException을 던질 수 있는 시그니처와 일치하는 함수형 인터페이스를 만들어야 한다. 이 인터페이스를 BufferedReaderProcessor 라고 정의하자.

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

정의한 인터페이스를 processFile 메서드의 인수로 전달할 수 있다.

public String processFile(BufferedReaderProcessor p) throws IOException {
		...
}

3.3.3 3단계 : 동작 실행

이제 BufferedReaderProcessor에 정의된 process 메서드의 시그니처(BufferedReader -> String)과 일치하는 람다를 전달할 수 있다.

processFile 바디 내에서 BufferedReaderProcessor 객체의 process를 호출할 수 있다.

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

3.3.4 4단계 : 람다 전달

이제 람다를 이용해 다양한 동작을 processFile 메서드로 전달할 수 있다.

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

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

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

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

[ processFile 메서드를 더 유연하게 만드는 과정 ]

3.4 함수형 인터페이스 사용

함수 디스크립터

함수형 인터페이스의 추상 메서드 시그니처

3.4.2 Consumer

java.util.function.Consumer 인터페이스는 **제네릭 형식 T 객체를 받아서 void를 반환**하는 accept라는 추상 메서드를 정의한다. T 형식의 객체를 인수로 받아 어떤 동작을 수행하고 싶을 때 Consumer 인터페이스를 사용할 수 있다.

다음은 forEach와 람다를 이용해서 리스트의 모든 항목을 출력하는 예제다.

@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),
				// Consumer의 accept 메서드를 구현하는 람다
				(Integer i) -> System.out.println(i) 
);

3.4.3 Function

java.util.function.Function<T, R> 인터페이스는 제네릭 형식 T를 인수로 받아서 제네릭 형식 R 객체를 반환하는 추상 메서드 apply를 정의한다. 입력을 출력으로 매핑하는 람다를 정의할 때 Function 인터페이스를 활용할 수 있다.(ex. 사과의 무게 정보를 추출하거나 문자열을 길이와 매핑)

다음은 String 리스트를 인수로 받아 각 String의 길이를 포함하는 Integer 리스트로 변환하는 map 메서드를 정의하는 예제다.

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

// [7, 2, 6]
List<Integer> l = map(
				Arrays.asList("lambdas", "in", "action"),
				(String s) -> s.length() // Function의 apply 메서드를 구현하는 람다
);

기본형 특화

지금까지 본 세 개의 제네릭 함수형 인터페이스 Predicate, Consumer, Function<T, R>을 살펴봤다. 이외에도 특화된 형식의 함수형 인터페이스도 있다.

자바는 기본형과 참조형 두 가지가 있는데, 제네릭 파라미터에는 참조형만 사용할 수 있다.

• 박싱 : 기본형을 참조형으로 변환
• 언박싱 : 참조형을 기본형으로 변환

• 오토박싱 : 박싱과 언박싱이 자동으로 이루어짐

    List<Integer> list = new ArrayList<>();
    for (int i = 300; i < 400; i++) {
    		list.add(i);
    }
  

  int가 Integer로 박싱되었다.

하지만 이런 변환 과정은 비용이 소모된다. 박싱한 값은 메모리를 더 소비하며 기본형을 가져올 때도 메모리를 탐색하는 과정이 필요하다.

자바 8에서는 오토박싱 동작을 피할 수 있도록 특별한 버전의 함수형 인터페이스를 제공한다.

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

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

IntPredicate evenNumbers = (int i) -> i % 2 == 0;
evenNumber.test(1000); // 참(박싱 없음)

Predicate<Integer> oddNumbers = (Integer i) -> i % 2 != 0;
oddNumbers.test(1000); // 거짓(박싱)

이렇게 특정 형식을 입력으로 받는 함수형 인터페이스 이름 앞에 형식명이 붙는다.

ex.) IntConsumer, LongBinaryOperator, IntFunction

Function 인터페이스 → ToIntFunction, IntToDoubleFunction 등 다양한 출력 형식 파라미터 제공