[Java] 람다식

 

https://github.com/whiteship/live-study

whiteship/live-study

백기선님 자바 기초 스터디 15주차

 

목표

자바의 람다식에 대해 학습하세요.

학습할 것 (필수)

• 람다식 사용법
• 함수형 인터페이스
• Variable Capture
• 메소드, 생성자 레퍼런스

 

람다식 사용법

람다식이란?

람다식(Lambda expression)은 메서드를 하나의 '식(expression)'으로 표현한 것이다. 메서드를 람다식으로 표현하면 메서드의 이름과 반환값이 없어지므로, 람다식을 '익명 함수(anonymous function)'이라고도 한다.

// 메서드
int method() {
    return (int) (Math.random() * 5) + 1;
}

// 람다식
(i) -> (int) (Math.random() * 5) + 1

메서드보다 람다식이 간결하면서도 이해하기 쉽다. 게다가 모든 메서드는 클래스에 포함되어야 하는데, 람다식은 오직 람다식 자체만으로도 메서드의 역할을 대신할 수 있다.

 

게다가 람다식은 메서드이 매개변수로 전달되어지는 것이 가능하고, 메서드의 결과로 반환될 수도 있다. 람다식으로 인해 메서드를 변수처럼 다루는 것이 가능해진 것이다.

// 람다식을 매개변수로
int[] arr = new int[5];
Arrays.setAll(arr, (i) -> (int) (Math.random() * 5) + 1);

 

람다식 작성하기

람다식은 '익명 함수' 답게 메서드에서 이름과 반환타입을 제거하고 매개변수 선언부와 몸통 { } 사이에 '->'를 추가한다.

// 메서드
반환타입 메서드이름(매개변수 선언) {
    문장들
}

// 람다식
(매개변수 선언) -> {
    문장들
}

 

예를 들어, 두 값 중에서 큰 값을 반환하는 메서드 max를 람다식으로 변환하면 다음과 같다.

// 메서드
int max(int a, int b) {
    return a > b ? a : b;
}

// 람다식
(int a, int b) -> {
    return a > b ? a : b;
}

 

반환값이 있는 메서드의 경우, return문 대신 '식(expression)'으로 대신할 수 있다. 식의 연산결과가 자동적으로 반환값이 된다. 이때는 '문장(statement)'이 아닌 '식'이므로 끝에 ';'을 붙이지 않는다.

(int a, int b) -> { return a > b ? a : b; }

(int a, int b) -> a > b ? a : b

 

람다식의 선언된 매개변수의 타입은 추론이 가능한 경우는 생략할 수 있는데, 대부분의 경우에 생략가능하다.

(int a, int b) -> a > b ? a : b

(a, b) -> a > b ? a : b

 

아래와 같이 선언된 매개변수가 하나뿐인 경우에는 괄호( )를 생략할 수 있다. 단, 매개변수 타입이 있으면 괄호( )를 생략할 수 없다.

(a) -> a * a
a -> a * a // Ok

(int a) -> a * a
int a -> a * a // 에러

 

마찬가지로 괄호 { } 안의 문장이 하나일 때는 괄호를 생략할 수 있다. 이 때 문장의 끝에 ';'을 붙이지 않아야 한다는 것에 주의하자.

(String name, int i) -> {
    System.out.println(name + "=" + i);
}

(String name, int i) -> 
    System.out.println(name + "=" + i)

 

그러나 괄호 { } 안의 문장이 return문일 경우 괄호{ }를 생략할 수 없다.

(int a, int b) -> { return a > b ? a : b; } // OK

(int a, int b) -> return a > b ? a : b // 에러

 

 

함수형 인터페이스

자바에서 모든 메서드는 클래스 내에 포함되어야 하는데, 람다식은 어떤 클래스에 포함되는 것일까? 지금까지 람다식이 메서드와 동등한 것처럼 설명해왔지만, 사실 람다식은 익명 클래스의 객체와 동등하다.

(int a, int b) -> a > b ? a : b

new Object() {
    int max(int a, int b) {
        return a > b ? a : b;
    }
}

 

예제에서 max는 임의로 붙인 것일 뿐 의미는 없다. 어쨌든 람다식으로 정의된 익명 객체의 메서드를 어떻게  호출할 수 있을 것인가? 참조변

수가 있어야 객체의 메서드를 호출할 수 있으니까 일단 이 익명 객체의 주소를 f라는 참조변수에 저장해보자.

타입 f = (int a, int b) -> a > b ? a : b;

참조변수 f의 타입은 어떤 것이어야 할까? 참조형이니까 클래스 또는 인터페이스가 가능하다. 그리고 람다식과 동등한 메서드가 정의되어 있는 것이어야 한다. 그래야만 참조변수로 익명 객체(람다식)의 메서드를 호출할 수 있기 때문이다.

 

예를 들어, 아래와 같이 max()라는 메서드가 정의된 MyFunction인터페이스가 정의되어 있다고 가정하자.

public interface MyFunction {
    public abstract int max(int a, int b);
}

 

그러면 이 인터페이스를 구현한 익명 클래스의 객체는 다음과 같이 생성할 수 있다.

MyFunction f = new MyFunction() {
    public int max(int a, int b) {
        return a > b ? a : b;
    }
};
int big = f.max(5, 3);

 

위 코드의 익명 객체를 람다식으로 아래와 같이 대체할 수 있다.

MyFunction f = (int a, int b) -> a > b ? a : b;
int big = f.max(5, 3);

이처럼 람다식도 실제로는 익명 객체이고, MyFunction인터페이스를 구현한 익명 객체의 메서드 max()와 람다식의 매개변수의 타입과 개수 그리고 반환값이 일치하기 때문에 MyFunction인터페이스를 구현한 익명 객체를 람다식으로 대체할 수 있다.

 

지금까지 살펴본 것처럼, 하나의 메서드가 선언된 인터페이스를 정의해서 람다식을 다루는 것은 기존의 자바 규칙들을 어기지 않는다. 따라서 인터페이스를 통해 람다식을 다루기로 결정되었고, 람다식을 다루기 위한 인터페이스를 '함수형 인터페이스(functional interface)'라고 한다.

 

함수형 인터페이스는 오직 하나의 추상 메서드만 정의되어 있어야 한다는 제약이 있다. 그래야 람다식과 인터페이스의 메서드가 1:1로 연결될 수 있기 때문이다. 반면에 static 메서드와 default 메서드의 개수에는 제약이 없다.

@FunctionalInterface
public interface MyFunction {
    public abstract int max(int a, int b);
}

이처럼 @FunctionalInterface를 붙이면 컴파일러가 함수형 인터페이스를 올바르게 정의하였는지 확인해주므로, 꼭 붙이도록 하자.

 

기존에는 아래와 같이 인터페이스의 메서드 하나를 구현하는데도 복잡하게 해야 했는데,

List<String> list = Arrays.asList("abc", "aaa", "bbb", "ddd", "aaa");
Collections.sort(list, new Comparator<String>() {
    public int compare(String o1, String o2) {
        return o2.compareTo(o1);
    }
});

 

이제 람다식으로 아래와 같이 간단히 처리할 수 있게 되었다.

List<String> list = Arrays.asList("abc", "aaa", "bbb", "ddd", "aaa");
Collections.sort(list, (s1, s2) -> s2.compareTo(s1));

 

함수형 인터페이스 타입의 매개변수와  반환타입

함수형 인터페이스 MyFunction이 아래와 같이 정의되어 있을 때,

@FunctionalInterface
public interface MyFunction {
    void myMethod();
}

 

메서드의 매개변수가 MyFunction타입이면, 이 메서드는 호출할 때, 람다식을 참조하는 참조변수를 매개변수로 지정해야한다는 뜻이다.

void aMethod(MyFunction f) {
    f.myMethod();
}

MyFunction f = () -> System.out.println("myMethod()");
aMethod(f);

// 참조변수 없이도 가능하다.
aMethod(() -> System.out.println("myMethod()"));

 

그리고 메서드의 반환타입이 함수형 인터페이스 타입이라면, 이 함수형 인터페이스의 추상 메서드와 동등한 람다식을 가리키는 참조변수를 반환하거나 람다식을 직접 반환할 수 있다.

MyFunction myMethod() {
    MyFunction f = () -> {};
    return f; // 혹은 return () -> {}; 도 가능하다.
}

 

람다식을 참조변수로 다룰 수 있다는 것은 메서드를 통해 람다식을 주고 받을 수 있다는 것을 의미한다. 사실상 메서드가 아니라 객체를 주고 받는 것이라 근본적으로 달라진 것은 아무것도 없지만, 람다식 덕분에 코드를 더 간결하게 작성할 수 있다.

 

람다식의 타입과 형변환

함수형 인터페이스로 람다식을 참조할 수 있는 것일 뿐, 람다식은 익명 객체이기 때문에 타입이 함수형 인터페이스의 타입과 일치하는 것은 아니다. 그래서 대입 연산자의 양변의 타입을 일치시키기 위해 아래와 같이 형변환이 필요하다.

MyFunction f = (MyFunction)(() -> {});

물론 람다식은 인터페이스를 구현한 클래스의 객체와 완전히 동일하기 때문에 이 형변환은 생략 가능하다.

 

람다식은 이름이 없을 뿐 분명히 객체인데도, 아래와 같이 Object 타입으로 형변환할 수 없다. 오직 함수형 인터페이스로만 형변환이 가능하다. 굳이 Object타입으로 형변환하려면, 먼저 함수형 인터페이스로 변환해야 한다.

Object obj = (Object)(() -> {}); // 에러.

Object obj = (Object)(MyFunction)(() -> {}); // OK

 

java.util.function 패키지

대부분의 메서든는 타입이 비슷하다. 매개변수가 없거나 한 개 또는 두 개, 반환 값은 없거나 한 개. 게다가 지네릭 메서드로 정의하면 매개변수나 반환 타입이 달라도 문제가 되지 않는다.

그래서 java.util.function 패키지에 일반적으로 자주 쓰이는 형식의 메서드를 함수형 인터페이스로 미리 정의해 놓았다.

 

자주 쓰이는 가장 기본적인 함수형 인터페이스는 다음과 같다.

함수형 인터페이스	메서드	설명
java.lang.Runnable	void run()	매개변수도 없고, 반환값도 없음
Supplier<T>	T get()	매개변수는 없고, 반환값만 있음.
Consumer<T>	void accept(T t)	매개변수만 있고, 반환값이 없음.
Function<T, R>	R apply(T t)	하나의 매개변수를 받아 결과를 반환
Predicate<T>	boolean test(T t)	매개변수는 하나. 반환 타입은 boolean

 

매개변수와 반환값의 유무에 따라 4개의 함수형 인터페이스가 정의되어 있고, Function의 변형으로 Predicate가 있는데, 조건식을 함수로 표현하는데 사용된다.

Predicate<String> isEmptyStr = s -> s.length() == 0;
String s = "";

if (isEmptyStr.test(s)) {
    System.out.println("This is an empty String.");
}

 

매개변수의 개수가 2개인 함수형 인터페이스는 이름 앞에 접두사 'Bi'가 붙는다.

함수형 인터페이스	메서드	설명
BiConsumer<T, U>	void accept(T t, U u)	두 개의 매개변수만 있고, 반환값이 없음.
BiFunction<T, U, R>	R apply(T t, U u)	두개의 매개변수를 받아 결과를 반환
BiPredicate<T, U>	boolean test(T t, U u)	매개변수는 둘. 반환 타입은 boolean

 

 

Variable Capture

람다식도 익명 객체이므로 람다식에서 외부에 선언된 변수에 접근하는 규칙은 익명 클래스의 경우와 동일하다. 다음 예제를 보자.

@FunctionalInterface
interface MyFunction {
    void myMethod();
}

class Outer {
    int val = 10; // Outer.this.val

    class Inner {
        int val = 20; // this.val

        void method(int i) {
            int val = 30;
//            i = 10; //에러. 상수의 값을 변경할 수 없음.

            MyFunction f = () -> {
                System.out.println(i);
                System.out.println(val);
                System.out.println(++this.val);
                System.out.println(++Outer.this.val);
            };

            f.myMethod();
        }
    }
}

class LambdaEx {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.method(100);
    }
}

예제는 람다식 내에서 외부에 선언된 변수에 접근하는 방법을 보여준다. 람다식 내에서 참조하는 지역변수는 final이 붙지 않았어도 상수로 간주된다. 람다식 내에서 지역변수 i와 val을 참조하고 있으므로 람다식 내에서나 다른 어느 곳에서도 이 변수들의 값을 변경하는 일은 허용되지 않는다.

반면에 Inner클래스와 Outer클래스의 인스턴스 변수인 this.val과 Outer.this.val은 상수로 간주되지 않으므로 값을 변경해도 된다.

 

그리고 외부 지역 변수와 같은 이름의 람다식 매개변수는 허용되지 않는다.

void method(int i) {
    int val = 30;

    MyFunction f = (i) -> { // 에러. 외부 지역변수와 이름이 중복됨.
        System.out.println(i);
        System.out.println(val);
        System.out.println(++this.val);
        System.out.println(++Outer.this.val);
    };

    f.myMethod();
}

 

 

메소드, 생성자 레퍼런스

메소드 레퍼런스

람다식을 더욱 간결하게 표현할 수 있는 방법이 있다. 항상 그런 것은 아니고, 람다식이 하나의 메서드만 호출하는 경우에는 '메소드 레퍼런스(method reference)'라는 방법으로 람다식을 간략히 할 수 있다. 예를 들어, 문자열을 정수로 변환하는 람다식은 아래와 같다.

Function<String, Integer> f = (String s) -> Integer.parseInt(s);

 

람다식을 메소드 레퍼런스를 통해 간략히 해보자.

Function<String, Integer> f = Integer::parseInt

컴파일러는 생략된 부분을 우변의 parseInt메소드의 선언부로부터, 또는 좌변의 Function 인터페이스에 지정된 제네릭 타입으로부터 쉽게 알아낼 수 있다.

 

한 가지 예를 더 보자. 아래의 람다식을 메소드 레퍼런스로 변경한다면, 어떻게 되겠는가?

BiFunction<String, String, Boolean> f = (s1, s2) -> s1.equals(s2);

 

BiFunction의 제네릭 타입만 봐도 람다식이 두 개의 String 타입의 매개변수를 받는다는 것을 알 수 있으므로, 람다식에서 매개변수들을 제거해메소드 레퍼런스로 변경할 수 있다.

BiFunction<String, String, Boolean> f = String::equals;

매개변수 s1과 s2를 생략해버리고 나면 equals만 남는데, 두 개의 String을 받아서 Boolean을 반환하는 equals라는 이름의 메소드는 다른 클래스에도 존재할 수 있기 때문에 equals앞에 클래스 이름은 반드시 필요하다.

 

이미 생성된 객체의 메서드를 람다식에서 사용한 경우에는 클래스 이름 대신 그 객체의 참조변수를 적어줘야 한다.

MyClass obj = new MyClass();
Function<String, Boolean> f = (x) -> obj.equals(x); // 람다식
Function<String, Boolean> f2 = obj::equals; // 메소드 레퍼런스

 

지금까지 3가지 경우의 메소드 레퍼런스에 대해서 알아봤는데, 정리하면 다음과 같다.

종류	람다	메서드 참조
static 메소드 레퍼런스	(x) -> ClassName.method(x)	ClassName::method
인스턴스 메소드 레퍼런스	(obj, x) -> obj.method(x)	ClassName::method
특정 객체 인스턴스 메소드 레퍼런스	(x) -> obj.method(x)	obj::method

 

생성자의 메소드 레퍼런스

생성자를 호출하는 람다식도 메소드 레퍼런스로 변환할 수 있다.

Supplier<MyClass> s = () -> new MyClass(); // 람다식
Supplier<MyClass> s2 = MyClass::new; // 메소드 레퍼런스

 

매개변수가 있는 생성자라면, 매개변수의 개수에 따라 알맞은 함수형 인터페이스를 사용하면 된다.

Function<Integer, MyClass> f = (i) -> new MyClass(); // 람다식
Function<Integer, MyClass> f2 = (i) -> MyClass::new; // 메소드 레퍼런스

BiFunction<Integer, String, MyClass> bf = (i, s) -> new MyClass(); // 람다식
BiFunction<Integer, String, MyClass> bf2 = (i) -> MyClass::new; // 메소드 레퍼런스

 

그리고 배열을 생성할 때는 아래와 같이 하면 된다.

Function<Integer, int[]> f = x -> new int[x]; // 람다식
Function<Integer, int[]> f2 = int[]::new; // 메소드 레퍼런스

 

메소드 레퍼런스난 람다식을 마치 static변수처럼 다룰 수 있게 해준다. 메소드 레퍼런스는 코드를 간략히 하는데 유용해서 많이 사용되기 때문에, 람다식을 메소드 레퍼런스로 변환하는 연습을 많이 해서 익숙해지면 좋다.