[모던자바인액션] 메서드 참조 : 람다를 간결하게 사용하기

💬 모던 자바 인 액션 챕터 3을 읽고 정리한 글입니다.

 

---

✔️ 메서드 참조

메서드 참조를 사용해서 더 코드를 간결하게 만들어보자.

// Before
inventory.sort((a1, a2) ->
         a1.getCourse().compareTo(a2.getCourse()));

// After
inventory.sort(comparing(Crew::getCourse));

메서드 이름을 활용하는, '메소드 참조'를 활용하면 람다를 더 간결하게 표현할 수 있다.

메서드 참조를 하기 위해서는 구분자(::)를 활용한다.

🌱 메서드 참조를 만드는 방법
1. 정적 메서드 참조 
(args) -> ClassName.staticMethod(args) ==> ClassName::staticMethod

2. 다양한 형식의 인스턴스 메서드 참조 
(arg0, rest) -> arg0.instanceMethod(rest) ==> ClassName::instanceMethod

3. 기존 객체의 인스턴스 메서드 참조 
(args) -> expr.instanceMethod(args) ==> expr::instanceMethod

여기서 핵심은, 메서드 참조가 콘텍스트의 형식과 일치해야 하는 것이다.

메서드 참조는 기본적으로 람다식을 축약하여 호출한다. 그렇기 때문에, 람다식과 마찬가지로 함수형 인터페이스의 인스턴스를 생성할 때 메서드 참조를 사용하게 된다. 이때, 함수형 인터페이스의 추상 메서드와 메서드 참조 대상 메서드의 시그니처가 일치해야 한다.

 

말을 이렇게 쓰니까 어려운데, 코드로 보면 간단하다.

public class Calculator {
    public int sum(int a, int b) {
        return a + b;
    }
}

인자로 받은 두 값을 더하는 메서드가 있다고 가정해보자. 우리는 호출부에서 다음과 같이 사용할 수 있다.

Calculator calculator = new Calculator();
IntBinaryOperator operator = calculator::sum;

생성한 메서드 참조인 calculator::sum의 반환형을 IntBinaryOperator로 받았다.

IntBinaryOperator는 int 타입의 매개변수 2개를 받아 int 타입의 결과를 반환하는 함수형 인터페이스이다.

이때, calculator::sum의 시그니처는 (int, int) -> int이고, IntBinaryOperator 역시 동일하다.

 

---

✔️ 생성자 참조

정적 메서드 참조처럼, 클래스명::new를 활용하면 생성자의 참조를 만들 수 있다.

// 기본적인 객체 생성 방법
Crew crew = new Crew();

// 생성자 참조 이용하기
Supplier<Crew> sup = Crew::new;
Crew crew = sup.get(); // get을 통해 객체 가져오기

// 매개변수가 존재할 경우 생성자 참조 이용하기
Function<String, Crew> func = Crew::new;
Crew crew = func.apply("journey"); // 인수 전달이 가능하다.

// 매개변수가 2개인 경우
BiFunction<String, Integer, Crew> bi = Crew::new;
Crew crew = bi.apply("journey", 23);

인자가 여러 개인 경우에는, 우리가 직접 커스텀한 인터페이스를 활용하면 된다.

만약 매개변수가 4개인 경우, 생성자 참조를 활용하고 싶다면 제네릭을 활용하여 다음과 같은 인터페이스를 생성하자.

public interface CustomFunction<T1, T2, T3, T4, R> {
    R apply(T1 t1, T2 t2, T3 t3, T4 t4);
}

// 간단한 크루 클래스
public class Crew {
    private final String name;
    private final String nickname;
    private final int age;
    private final String courseName;

    public Crew(final String name, final String nickname, final int age, final String courseName) {
        this.name = name;
        this.nickname = nickname;
        this.age = age;
        this.courseName = courseName;
    }
}

그러면 실제로 아래와 같이 적용해주면 된다.

CustomFunction<String, String, Integer, String, Crew> crewFactory = Crew::new;

 

또한, 생성자 참조를 활용하면 인스턴스화 하지 않더라도 생성자에 접근할 수 있다.

public class Crew {
    private final String courseName;

    public Crew(final String courseName) {
        this.courseName = courseName;
    }

    public String getCourseName() {
        return courseName;
    }
}

위와 같은 간단한 크루 클래스가 있다고 생각해보자.

public class Main {
    private static final Map<String, Function<String, Crew>> map = new HashMap<>();

    public static void main(String[] args) throws IOException {
        map.put("backend", Crew::new);
        map.put("frontend", Crew::new);

        Crew crew = getCrew("backend", "backend");
        System.out.println(crew.getCourseName()); // backend
    }

    public static Crew getCrew(String course, String courseName) {
        return map.get(course).apply(courseName);
    }
}

위의 코드처럼, map을 통해 특정한 해시값을 key로 두고, 해당 해시값으로 객체를 미리 생성해둔다. (일종의 캐싱 개념이다)

그리고, 해당 해시값을 통해 map에 요청하면 .apply()를 통해 객체를 생성하여 사전에 인스턴스화한 객체를 반환해줄 수 있다.

 

---

✔️ 람다, 메서드 참조

우리는 크루에 대해 정렬하는 코드를 작성해보자. 이때, 람다를 활용하여 멋지게 변환을 해줄 것이다.

 

1. sort() 메서드에게 동작 파라미터화 적용하기

// crew에 대한 comparator 생성하기
public class CrewComparator implements Comparator<Crew> {
    public int compare(Crew a1, Crew a2) {
        return Integer.compare(a1.getAge(), a2.getAge());
    }
}

// 다음과 같이 인자로 전달할 수 있다.
List<Crew> crews = new ArrayList<>();
crews.sort(new CrewComparator());

sort가 어떤 식으로 정렬할 것인지에 대한 기준을 인자로 넘겨줄 수 있다.

 

 

2. 새로운 클래스를 만들지 않고, 익명 클래스 활용하기

List<Crew> crews = new ArrayList<>();

crews.sort(new Comparator<Crew>() {
  @Override
  public int compare(final Crew o1, final Crew o2) {
      return Integer.compare(o1.getAge(), o2.getAge());
  }
});

클래스를 생성하지 않고, 익명 클래스를 통해서 바로 위와 같이 정의를 하였다.

참고로, age의 타입이 Integer라면 바로 o1.getAge().compareTo(o2.getAge())를 활용해도 좋다.

위에서는 primitive 타입을 사용한다고 가정하고 Integer.compare를 활용하였다.

(int 타입이라고 해서 두 값을 바로 뺀 값을 사용하면 오버플로가 발생할 수 있기 때문에 조심해야 한다.)

 

 

3. 람다 표현식을 사용해서 코드를 간결하게 만들기

현재 Comparator는 compare()라는 추상 메서드가 하나만 존재하고 있기 때문에 함수형 인터페이스이다.

이때, 추상 메서드의 시그니처 (= 함수 디스크립터)는 (T, T) → int이며, 우리는 이러한 시그니처와 동일하게 람다 표현식을 작성할 수 있다.

List<Crew> crews = new ArrayList<>();
crews.sort((Crew o1, Crew o2) -> Integer.compare(o1.getAge(), o2.getAge()));

컴파일러는 컨텍스트를 활용하여 람다의 파라미터 형식을 추론할 수 있다.

그렇기 때문에 앞에 선언한 Crew는 제거해줘도 된다.

List<Crew> crews = new ArrayList<>();
crews.sort((o1, o2) -> Integer.compare(o1.getAge(), o2.getAge()));

위 코드를 더 간결하게 해보자.

Comparator는 내부적으로 다음과 같은 메서드를 가지고 있다.

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

 

Comparator는 위와 같이 내부적으로 comparing()이라는 정적 메서드를 가지고 있는데, 여기서 내부 인자로 Function<T>형을 받는 것을 볼 수 있다. Function의 함수 디스크립터는 T → R이고, 여기서 T는 우리가 정렬할 객체, R는 정렬 기준에 대한 필드를 의미한다.

 

우리는 크루를 나이 기준으로 정렬할 것이기 때문에, 다음과 같이 Comparator의 정적 메서드 comparing을 호출할 수 있다.

Comparator<Crew> c = Comparator.comparing((Crew a) -> a.getAge());

그리고, 다시 sort의 인자로 Comparator를 넘겨주자.

List<Crew> crews = new ArrayList<>();
crews.sort(Comparator.comparing((Crew crew) -> crew.getAge()));

 

4. 람다 표현식을 간결하게 만들기, 메서드 참조를 이용하자!

다음과 같이 메서드 참조를 통해서 조금 더 간결하게 만들 수 있다.

List<Crew> crews = new ArrayList<>();
crews.sort(Comparator.comparing(Crew::getAge));

이렇게 되면 초반에 비해 매우 코드가 간결해지며, crew의 age를 기준으로 정렬하라는 것을 쉽게 파악할 수 있게 된다.

 

---

✔️ 람다 표현식 응용하기

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

이는 디폴트 메서드 덕분인데, 챕터가 나아가며 서서히 풀릴 내용이기 때문에 지금은 넘어가도록 하자.

조금 더 스킬적인 내용이기 때문에 별도로 풀어서 설명하기보다는, 이런 것도 있구나… 하고 넘어가는 용도로 정리하면 좋다.

 

💬 Comparator 활용하기

우리가 만약 크루들의 나이를 역순으로 정렬하고 싶다면 어떻게 해야 할까?

crews.sort(Comparator.comparing(Crew::getAge).reversed());

comparing()의 리턴값은 결국 Comparator이기 때문에, chaining을 통해서 쉽게 역정렬도 가능하다.

Comparator에는 reversed()라는 디폴트 메서드가 구현되어 있기 때문에 이렇게 호출할 수 있는 것이다.

// Comparator.java
default Comparator<T> reversed() {
    return Collections.reverseOrder(this);
}

위의 코드가 Comparator 인터페이스에 정의된 디폴트 메서드이다. 

 

혹은, 크루의 나이, 그리고 이름순으로 정렬하고 싶다면 어떻게 할까?

crews.sort(Comparator.comparing(Crew::getAge)
        .reversed()
        .thenComparing(Crew::getName));

thenComparing을 통해서 두 번째 정렬 기준을 넘겨주면 된다.

 

 

💬 Predicate 활용하기

만약, 참-거짓으로 분류되는 조건에 대해 필터링을 진행한다면 다음과 같이 체이닝을 걸어줄 수 있다.

// 백엔드인 크루를 필터링하는 predicate
Predicate<Crew> coursePredicate = (Crew crew) -> crew.getCourseName().equals("backend");

// 해당 필터링에 대해 반전시키는 predicate
Predicate<Crew> notBackendPredicate = coursePredicate.negate();

// predicate의 and (교집합), or (합집합)
// 20살 이상이면서 백엔드 코스거나, 이름이 져니인 조건
coursePredicate.and(crew -> crew.getAge() >= 20)
        .or(crew -> crew.getName().equals("journey"));

 

💬 Function 활용하기

h = f.andThen(g)

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

 

h = f.compose(g)

compose는 인수로 주어진 함수를 먼저 실행하고, 그 결과를 외부 함수의 인수로 제공한다.

// andThen() : g(f(x))
// (x + 1) * 2
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); // (1+1) * 2 = 4

// compose() : f(g(x)) 
// (x * 2) + 1
Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2;
Function<Integer, Integer> h = f.compose(g);
int result = h.apply(1); // (1*2) + 1 = 3

코드 내부는 이렇게 생겼다 :D

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
}

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
    Objects.requireNonNull(before);
    return (V v) -> apply(before.apply(v));
}

 

---

마지막으로 정리해보자! 챕터 3은 내용이 많지만, 그만큼 중요한 부분이었던 것 같다.

- 람다 표현식은 익명 함수의 일종이다. 이름은 없지만, 파라미터 리스트, 바디, 반환 형식을 가지며 예외를 던질 수 있다.
- 함수형 인터페이스는 하나의 추상 메서드만을 정의하는 인터페이스이다.
- 함수형 인터페이스를 기대하는 곳에서만 람다 표현식을 사용할 수 있다.
- 람다 표현식을 이용해서 함수형 인터페이스의 추상 메서드를 즉석으로 제공할 수 있으며, 람다 표현식 전체가 함수형 인터페이스의 인스턴스로 취급된다.
- 메서드 참조를 활용하면 메서드 구현을 재사용하고, 직접 전달할 수 있다.