[CHAPTER 3] - 람다 표현식

[JoisFe]

[CHAPTER 3] - 람다 표현식

Before

• 동작 파라미터화를 이용하여 변경되는 요구사항에 유연하게 대응하는 코드 작성 가능
• 익명 클래스로도 동작 파라미터화가 가능

문제점

• 익명 클래스로 작성한 코드는 깔끔하지 못함
• 실전 적용에 힘듬 (유지 보수가 힘듬)

해결책

• 람다를 사용

람다(Lambda) 란?

람다 표현식

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

특징

• 익명 : 일반적인 메서드와 달리 이름이 없음 -> 익명
  • 이름이 없으므로 메서드 이름 지을 고민거리가 줄어듬
• 함수 : 람다는 메서드처럼 특정 클래스에 종속적이지 않음 -> 함수
• 전달 : 람다 표현식을 메서드 인수로 전달하고나 변수로 저장할 수 있음
• 간결성 : 익명 클래스처럼 자질구레한 코드 구현할 필요 없음

람다의 간결성 예

• 위 코드는 익명클래스를 사용한 예

 List<Melon> tastelessMelons = Filters.filterMelons(melons, new MelonPredicate() {
            @Override
            public boolean test(Melon melon) {
                return "맛없는 멜론".equalsIgnoreCase(melon.getType());
            }
        });

• 위 코드는 같은 기능을 하는 람다를 사용한 예

    List<Melon> tastelessMelons = Filters.filterMelons(melons, melon -> "맛없는 멜론".equalsIgnoreCase(melon.getType()));

• 람다를 사용했을 때 코드가 훨씬 간결해 졌음을 확인할 수 있음

람다 표현식

• 파라미터 리스트 : Comparator의 compare 메서드 파라미터 (Apple 2개)
• 화살표 : 화살표는 람다의 파라미터 리스트와 바디 구분
• 람다 바디 : 두 사과의 무게를 비교 (람다의 반환값에 해당하는 표현식)

잘못된 람다 표현식의 예

• 잘못된 예 1

(Integer i) -> return "busnug92" + i;

• return은 흐름 제어문으로 code block이 있어야 함
• 올바른 예 1

(Integer i) -> { return "busnug92" + i; }

• 잘못된 예 2

(String s) -> { "�Corock"; }

• 람다 바디에 {} (코드 블록을 씌움)
• 코드 블록 내부는 statement로 작성이 되어야함 (코드 블록으로 둘러싼 이상 코드 블록 내부를 컴파일러는 표현식으로 보지 않음)
• 컴파일러는 "Corock";을 뭐 어쩌라고? 가 되는거임

``` java
(String s) -> { return "�Corock"; }

• 코드 블록 안에는 명확하게 원하는 목적의 statement로 작성해줘야함
• 여기서는 "Corock" 문자열을 return 해라

``` java
(String s) -> "�Corock";

• 코드 블록을 없애고 statement(구문)가 아니라 expression(표현식) 으로 작성함
• 그럼 컴파일러는 람다 표현식으로 이해하고 알맞게 해석함 (return "Corock"; 으로)

람다 표현식을 어디에 (Where) 사용?

• 함수형 인터페이스라는 문맥에서 람다 표현식을 사용할 수 있음

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

• 해당 코드는 함수형 인터페이스 Predicate<T>를 기대하는 filter 메서드의 두 번째 인수로 람다 표현식을 전달
• 함수형 인터페이스 ? Predicate ? filter ? 이게 다뭐야 ?? -> 이후에 알 수 있음

함수형 인터페이스

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

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

• 위 예시 코드는Predicate<T> 인터페이스로 필터 메서드를 파라미터화 한 것임
• Predicate<T>가 함수형 인터페이스 중 하나

함수형 인터페이스로 할 수 있는 것

• 람다 표현식으로 함수형 인터페이스의 추상 메서드 구현을 직접 전달 -> 전체 표현식을 함수형 인터페이스의 인스턴스로 취급 (기술적으로는 함수형 인터페이스를 구현한 클래스의 인스턴스)

함수 디스크립터 (function descriptor)

• 함수형 인터페이스의 추상 메서드 시그니처가 곧 람다 표현식의 시그니처
• 람다 표현식의 시그니처를 서술하는 메서드를 함수 디스크립터라고 함

람다의 활용 : 실행 어라운드 패턴 (Execute Around Pattern)

• 우리가 자주 사용하는 DB 파일 처리와 같은 자원 처리에 사용하는 순환 패턴(recurrent pattern)을 예시로 코드를 들고자 함
  • 자원 열기 -> 처리 -> 자원 닫는 순서
  • 이러한 형식의 코드를 실행 어라운드 패턴이라 함

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

위 코드의 문제점

• 위 코드는 파일에서 한 번에 한 줄만 읽을 수 있음
• 한 번에 두 줄을 읽거나 자주 사용되는 단어를 반환하고자 함

동작 파라미터화!!!

• 기존의 설정, 정리 과정은 재사용 하고 싶고 processFile 메서드만 다른 동작을 수행하도록 명령하게 하면 됨
  • processFile의 동작을 파라미터화 !!
  • processFile 메서드가 BufferedReader를 이용해 다른 동작을 수행할 수 있도록 processFile 메서드로 동작을 전달!
• processFile 메서드가 한 번에 두행을 읽게하기 위해 우선 BufferedReader를 인수로 받아 String으로 반환하는 람다가 필요

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

함수형 인터페이스를 이용해서 동작 전달

• 이전에 배웠듯 함수형 인터페이스 자리에 람다를 사용할 수 있음
• ` BufferedReader -> String 과 IOException을 throw할 수 있는 시그니처와 일치하는 함수형 인터페이스를 만들어야 함

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

public String processFile(BufferedReaderProcessor p) throws IOException {
}

• 위 인터페이스를 processFile의 메서드의 인수로 전달 가능

동작 실행!

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

람다 전달

• 람다를 이용해 다양한 동작을 processFile 메서드로 전달 가능

• 1. 한 행을 처리하는 코드

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

• 2. 두 행을 처리하는 코드

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

함수형 인터페이스 (Functional Interface)

• 오직 하나의 추상 메서드를 지정하는 인터페이스
• 함수형 인터페이스의 추상 메서드의 시그니처를 함수 디스크립터
• 다양한 람다 표현식을 사용하기 위해 공통의 함수 디스크립터를 기술하는 함수형 인터페이스 집합이 필요
• 자바 API 에는 Comparable, Runnable, Callable 등 다양한 함수형 인터페이스 포함
• java 8 라이브러리 설계자들은 java.utml.function 패키지로 여러가지 새로운 함수형 인터페이스 제공

Predicate

• java.util.function.Predicate<T> 인터페이스는 test 라는 추상메서드를 정의
• test 는 제네릭 형식 T 객체를 인수로 받아 boolean을 반환
• 이전에 filterMelons 메서드를 정의한 함수형 인터페이스를 만들었는데 Predicate 함수형 인터페이스와 같음 (filterMelons와 test가 같은 함수 디스크립터)
• 따라서 따로 함수형인터페이스를 정의할 필요 없이 바로 사용 가능
• T 형식의 객체를 사용하는 boolean 표현식이 필요한 상황에서 Predicate 인터페이스를 사용하면 됨

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

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

Consumer

• java.util.function.Consumer<T> 인터페이스는 제네릭 형식 T 객체를 받아 void를 반환하는 accept 추상메서드 정의

@FunctionalInterface
public class 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);
)

Function

• java.util.function.Function<T, R> 인터페이스는 제네릭 형식 T를 인수로 받아서 제네릭 형식 R 객체를 반환하는 추상 메서드 apply를 정의

@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> l = map (
    Arrays.asList("corock", "in", "studyroom"),
    (String s) -> s.length()
);

기본형 특화

• 위 에서 언급한 Predicate, Consumer, Function 과 달리 특화된 형식의 함수형 인터페이스 또한 존재
• 자바의 모든 형식은 참조형 or 기본형
• 제네릭 파라미터에는 참조형만 사용 가능
• 기본형을 참조형으로 변환하는 기능을 제공함 (박싱(Boxing), 언박싱(UnBoxing), 오토박싱(AutoBoxing))

박싱 ,언박싱, 오토박싱의 문제점

• 이러한 기능의 문제점은 변환 과정에서 일어나는 비용 소모

해결책

• 자바 8에서 이러한 문제점을 해결하기 위해 기본형을 입출력을 사용하는 상황에서 오토박싱 동작을 피할 수 있도록 특별한 버전의 함수형 인터페이스 제공

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

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

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

• 일반적으로 특정 형식을 입력으로 받는 함수형 인터페이스의 이름 앞에는 DoublePredicate, IntConsumer, LongBinaryOperator, IntFunction 과 같이 형식명이 붙음

자바 8에 추가된 함수형 인터페이스 (대표적 함수형 인터페이스, 함수 디스크립터)

함수형 인터페이스	함수 디스크립터	기본형 특화

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

• 람다로 함수형 인터페이스의 인스턴스를 만들 수 있음
• 그러나 람다 표현식 자체는 람다가 어떤 함수형 인터페이스를 구현하는지에 대한 정보가 없음

형식(type) 검사

• 람다가 사용하는 context를 이용해 람다의 형식을 추론 가능
• 대상 형식 (target type) : 어떤 콘텐스트에서 기대되는 람다 표현식의 형식

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

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