[JAVA] 람다식 - 메소드::참조 문법

람다식 메소드::참조

---

자바의 람다표현식을 통해 코드 정의를 줄여주었지만 이보다 더 간략하게 줄이는 문법이 있다.

 

메소드 참조(Method Reference)는 말 그대로 실행하려는 메소드를 참조해서 매개 변수의 정보 및 리턴 타입을 알아내어, 람다식에서 굳이 선언이 불필요한 부분을 생략하는 것을 말한다.

 

람다식은 복잡하고 긴 로직보단 기존 메소드들을 단순히 호출만 하는 경우가 많다. 예를 들어 두 개의 값을 받아 작은 수를 리턴하는 Math 클래스의 max() 정적 메소드를 호출하는 람다식은 다음과 같다.

(x, y) -> Math.max(x, y)

이 자체로도 간략해 보이지만, 개발자의 욕심은 끝도 없다. 함수 형태를 보면 리턴값 자체가 또다른 Math 클래스의 메소드를 호출하는 것 뿐이고, 람다 함수의 매개변수 역시 그대로 max() 메서드의 매개변수로 들어가기 때문에 코드 중복이 발생하기 때문이다.

따라서 중복되는 매개변수를 없애고, 화살표를 없애고, 클래스가 메소드를 참조하는 기호인 . 기호를 :: 기호로 변환하면 다음과 같이 표현 할 수 있게 된다.

Math::max; // (x, y) -> Math.max(x, y)

 

 

---

메서드 참조 조건과 타입 추론

만약 Math::min 메서드 참조를 변수에 담고 싶다면, 함수형 인터페이스타입인 IntBinaryOperator 인터페이스를 사용하면 된다. 두 개의 int 형 입력값을 받아 int 값을 리턴하는 함수 디스크립터를 갖고 있기 때문이다.

IntBinaryOperator b = Math::min;
b.applyAsInt(100, 200); // 100

이런식으로 문법 함축이 가능한 이유는 컴파일러가 람다식의 타입을 추론하기 때문이다. 이때 람다 타입 추론은 기존의 람다 익명 함수와는 약간 차이가 있다. 오히려 더 간단한데, 인터페이스의 추상 메서드 형태와 반환 메서드의 시그니처 형태가 같으면 된다.

위의 그림과 같이, IntBinaryOperator 인터페이스의 추상 메서드는 int형 매개변수 2개를 받으며 반환 타입이 int형이고, Math 클래스의 max 메서드 역시 타입이 똑같이 구성되어 있기 때문에, 이를 컴파일러가 추론해서 가능한 것이다.

 

정리하자면, 람다식의 메소드 참조 문법을 사용하기 위해서는 다음의 3가지 조건을 만족하면 된다.

• 함수형 인터페이스의 매개변수 타입 == 메소드의 매개변수 타입
• 함수형 인터페이스의 매개변수 개수 == 메소드의 매개변수 개수
• 함수형 인터페이스의 반환 타입 == 메소드의 반환 타입

---

메서드 참조 종류

어떠한 메서드를 참조하여 실행하느냐에 메소드 참조도 종류가 나뉘게 된다.

종류	람다 표현식	메서드 참조
정적 메서드 참조	(x) -> ClassName.method(x)	ClassName::method
인스턴스 메서드 참조	(x) -> obj.method(x)	obj::method
매개변수의 메서드 참조	(obj, x) -> obj.method(x)	ClassName::method
생성자 참조	(x, y) -> new ClassName(x, y)	ClassName::new

 

정적 메소드 참조

다음은 Interger 클래스의 parseInt() 정적 메서드를 호출하는 람다식을 메소드 참조로 리팩토링한 예제이다.

 

정적 메소드를 참조할때, 메서드 참조 :: 기호 앞부분에 클래스명을 그대로 기재하는 것이 특징이다.

Function<String, Integer> stringToInt;

// (x) -> ClassName.method(x)
stringToInt = (s) -> Integer.parseInt(s);

// ClassName::method
stringToInt = Integer::parseInt;

stringToInt.apply("100");

 

 

인스턴스 메소드 참조

다음은 ArrayList 클래스의 인스턴스를 만들고 인자로 Collection을 받아 리스트에 요소들을 추가하는 람다식을 메소드 참조로 리팩토링한 예제이다.

 

인스턴스의 메소드를 참조할때, 메서드 참조 :: 기호 앞부분에 상단에 선언한 인스턴스 변수를 기재하는 것이 특징이다.

ArrayList<Number> list = new ArrayList<>();
Consumer<Collection<Number>> addElements;

// (x) -> obj.method(x)
addElements = (arr) -> list.addAll(arr);

// obj::method
addElements = list::addAll;

addElements.accept(List.of(1, 2, 3, 4, 5));

System.out.println(list); // [1, 2, 3, 4, 5]

 

 

매개변수의 메서드 참조

다음은 String 클래스의 인스턴스를 받아 문자열의 길이를 구하는 람다식을 메소드 참조로 리팩토링한 예제이다.

 

매개변수의 메소드를 참조할때, 메서드 참조 :: 기호 앞부분에 정적 메소드 참조와 똑같이 매개변수의 클래스 타입명을 기재하는 것이 특징이다.

Function<String, Integer> size;

// (obj, x) -> obj.method(x)  
size = (String s1) ->  s1.length();

// ClassName::method
size = String::length;

size.apply("Hello World"); // 11

 

 

생성자 참조

생성자도 일종의 메소드 이기 때문에 메서드 참조가 가능하다. 리턴값이 단순히 객체를 생성하는 것이기 때문에 적용이 가능한 것이다. 대신 생성자는 고유 메서드명이 없기 때문에 new 로 표시한다.

BiFunction<Integer, Integer, Object> constructor;

// (x, y) -> new ClassName(x, y)  
constructor = (x, y) -> new Object(x, y);

// ClassName::new
constructor = Object::new;

이때 생성자 오버로딩을 통해 매개 변수 개수에 따라서 인스턴스화를 구현하려고 할때, 람다식을 각기 다른 함수형 인터페이스에 대입하여 실행시켜야 한다.

import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

class Customer {
    String name;
    int age;

    public Customer() {
    }

    public Customer(String name) {
        this.name = name;
    }

    public Customer(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public static void main(String[] args) {
    // 생성자 인자 없이 생성할때
    Supplier<Customer> function1 = Customer::new;
    Customer customer1 = function1.get();

    // 생성자 인자 1개로만 생성할때 (입력타입, 생성자클래스)
    Function<String, Customer> function2 = Customer::new;
    Customer customer2 = function2.apply("홍길동");

    // 생성자 인자 2개로만 생성할때 (입력타입1, 입력타입2, 생성자클래스)
    BiFunction<String, Integer, Customer> function3 = Customer::new;
    Customer customer3 = function3.apply("홍길동", 55);
}

이를 고급 응용하자면 Map 컬렉션에 생성자 람다를 넣어서 인스턴스 관리를 통해 '지연 인스턴스화' 기법을 구현할 수 있다. 이 기법은 다이나믹 팩토리 패턴으로서 리플렉션 대안으로 응용이 가능하다.

class Fruit {}

class Apple extends Fruit {
    int count;

    public Apple(int count) {
        this.count = count;
    }
}
class Banana extends Fruit {
    int count;

    public Banana(int count) {
        this.count = count;
    }
}

class Constructor {
    public static Map<String, Function<Integer, Fruit>> map = new HashMap<>();

    static {
        map.put("apple", Apple::new);
        map.put("banana", Banana::new);
    }

    public static Fruit makeFruit(String name, int count) {
        if(map.containsKey(name)) {
            return map.get(name.toLowerCase()).apply(count);
        }
        return null;
    }
}

public static void main(String[] args) {
    Apple apples = (Apple) Constructor.makeFruit("apple", 10);
    Banana bananas = (Banana) Constructor.makeFruit("banana", 4);
}

 

 

---

참고

• https://dev-kani.tistory.com/38
• https://steady-coding.tistory.com/307