[첫번째 프로젝트] 3. 람다

0. 람다식 배경

자바에서는 큰 변화가 두 번 있었습니다. 한번은 JDK 1.5부터 추가된 지네릭스(Generices)등장이고, 또 한 번은 JDK 1.8부터 추가된 람다식(Lambda expressiin)의 등장입니다. 이 두 가지 새로운 변화에 의해 자바는 많이 변경되었습니다. 특히 람다식의 도입으로 인해, 이제 자바는 객체지향언어인 동시에 함수형 언어가 되었습니다.

1. 람다식

람다식(Lambda expression)은 간단히 말해서 메서드를 하나의 식(expression)으로 표현하는 것을 의미합니다. 람다식은 함수를 간략하면서도 명확한 식으로 표현할 수 있게 해줍니다. 메서드를 람다식으로 표현하면 메서드의 이름과 반환값이 없어지므로, 람다식을 '익명 함수(anonymous function)'이라고도 합니다.

int[] arr = new int[5];
Arrays.setAll(arr, (i) -> (int)(Math.random() * 5) + 1);

다음 예제의 람다식이 하는 일을 메서드로 표현하면 다음과 같습니다.

int method() {
    return (int)(Math.random() * 5) + 1;
}

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

2. 람다식 작성하기

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

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

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

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

int max(int a, int b) {
    retrun a > b ? a : b;
}

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

2.1 반환값이 있는 람다식

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

(int a, int b) -> { return a > b ? a : b; } 
(int a, int b) -> a > b ? a : b // retrun 생략할 때는 세미콜론도 함께 생략합니다.

2.2 타입 추론 람다식

람다식이 선언된 매개변수의 타입은 추론이 가능한 경우는 생략할 수 있는데, 대부분의 경우에 생략이 가능합니다.
람다식에 반환타입이 없는 이유도 항상 추론이 가능하기 때문입니다.

(int a, int b) -> a > b ? a : b
(a, b) -> a > b ? a: b // int 타입 생략 가능합니다.

단, 주의해야 할 점은 (int a, b) -> a > b ? a : b? 와 같이 두 매개변수 중 어느 하나의 타입만 생략하는 것은 허용되지 않습니다.

2.3 매개변수 1개 람다식

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

// 1. 괄호 () 가 있는 람다식
(a) -> a * a // OK
(int a) -> a * a // OK
    
// 2. 괄호 () 가 없는 람다식
a -> a * a // OK
int a -> a * a // 에러

2.4 문장 1개 람다식

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

// 1. 중괄호 {} 가 있는 람다식
(String name, int i) -> {
    System.out.println(name + "=" + i);
}

// 2. 중괄호 {} 가 없는 람다식
(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 // 에러

2.5 람다식 예제1

아래는 메서드를 람다식으로 변환된 코드 예제입니다.
람다식을 가리고 왼쪽의 메서드만 보면서 람다식으로 변환하는 방법을 생각해보세요.

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

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

// printVar 메서드
void printVar(String name, int i) {
    System.out.println(name + "=" + i);
}

// printVar 람다식
(String name, int i) -> { System.out.println(name + "=" + i); }
(name, i) -> { System.out.println(name + "=" + i); }
(name, i) -> System.out.println(name + "=" + i)

// square 메서드
int square(int x) {
    return x * x;
}

// square 람다식
(int x) -> { return x * x; }
(x) -> x * x
x -> x * x

// roll 메서드
int () {
    return (int)(Math.random() * 6); 
}

// roll 람다식
() -> { return (int)(Math.random() * 6); }
() -> (int)(Math.random() * 6)

// sumArr 메서드
int sumArr(int[] arr) {
    int sum = 0;
    for(int i : arr) {
        sum += 1;
    }
    return sum;
}

// sumArr 람다식
(int[] arr) -> {
    int sum = 0;
    for(int i : arr) {
        sum += 1;
    }
    return sum;
}

3. 함수형 인터페이스

3.1 함수형 인터페이스 검증

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

(int a, int b) -> a > b ? a : b // 람다식

new Object() { // Object 클래스
    int max(int a, int b) { // max 메서드
        return a > b ? a : b;
    }
}

Object 클래스 안에 max는 임의로 붙인 것일 뿐 의미가 없습니다. 어쨋든 람다식으로 정의된 익명 객체의 메서드를 어떻게 호출할 수 있을까요? 이미 알고 있는 것처럼 참조변수가 있어야 객체의 메서드를 호출할 수 있으니까 일단 이 익명 객체의 주소를 f라는 참조변수에 저장합니다.

타입 f = (int a, int b) -> a > b ? a : b; // 참조변수의 타입을 뭘로 해야 할까요?

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

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

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 인터페이스에 정의된 메서드 max()는 람다식 (int a, int b) -> a > b ? a : b과 메서드의 선언부가 일치합니다.
그래서 위 코드의 익명 객체를 람다식으로 아래와 같이 대체할 수 있습니다.

MyFunction f = (int a, int b) -> a > b ? a : b; // 익명 객체를 람다식으로 대체
int big = f.max(5, 3); // 익명 객체의 메서드를 호출

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

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

@FunctionalInterface
interface MyFunction { // 함수형 인터페이스 MyFunction 정의
    public abstract int max(int a, int b);
}

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

참고: @FunctionalInterface를 붙이면, 컴파일러가 함수형 인터페이스를 올바르게 정의하여쓴ㄴ지 확인해주므로, 꼭 붙이도록 합니다.

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

List<String> list = Arrays.asList("abc", "aaa", "bbb", "ccc", "ddd", "aaa");

Collections.sort(list, new Comparator<String>() {
    public int compare(String s1, String s2)
        return s2.compareTo(s1);
});

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

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

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

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

@FunctionalInterface
interface MyFunction {
    void myMethod(); // 추상 메서드
}

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

void aMethod(MyFunction f) { // 매개변수의 타입이 함수형 인터페이스
    f.myMethod(); // MyFunction에 정의된 메서드 호출
    ...
    MyFunction f = () -> System.out.println("myMethod()");
    aMethod(f);
}

또는 참조변수 없이 아래와 같이 직접 람다식을 매개변수로 지정하는 것도 가능합니다.

aMethod(() -> System.out.println("myMethod()")); // 람다식을 매개변수로 지정

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

MyFunction myMethod() {
    MyFunction f = () -> {};
    return f; // 이 줄과 윗 줄을 한줄로 줄이면, return () -> {};
}

람다식을 참조변수로 다룰 수 있다는 것은 메서드를 통해 람다식을 주고받을 수 있다는 것을 의미합니다. 즉, 변수처럼 메서드를 주고받는 것이 가능해진 것입니다. 사실상 메서드가 아니라 객체를 주고받는 것이라 근본적으로 달라진 것은 아무것도 없지만, 람다식 덕분에 예전보다 코드가 더 간결하고 이해하기 쉬워집니다.

package limdae.dev;

@FunctionalInterface
interface MyFunction {
    void run(); // public abstract void run();
}

public class test {
    static void execute(MyFunction f) { // 매개변수의 타입이 MyFunction인 메서드
        f.run();
    }

    static MyFunction getMyFunction() { // 반환 타입이 MyFunction인 메서드
        MyFunction f = () -> System.out.println("f3.run");
        return f;
    }


    public static void main(String[] args) {
        // 람다식으로 MyFunction의 run()을 구현
        MyFunction f1 = () -> System.out.println("f1.run()");

        MyFunction f2 = new MyFunction() {
            @Override
            public void run() {
                System.out.println("f2.run()");
            }
        };

        MyFunction f3 = getMyFunction();

        f1.run();
        f2.run();
        f3.run();

        execute(f1);
        execute(() -> System.out.println("run()"));
    }
}

// 실행 결과
f1.run()
f2.run()
f3.run
f1.run()
run()

3.3 람다식의 타입과 형변환

함수형 인터페이스로 람다식을 참조할 수 있는 것일 뿐, 람다식의 타입이 함수형 인터페이스 타입과 일치하는 것은 아닙니다. 람다식은 익명 객체이고 익명 객체는 타입이 없습니다. 정확히는 타입이 있지만 컴파일러가 임의로 이름을 정하기 때문에 알 수 없는 것입니다. 그래서 대입 연산자의 양변의 타입을 일치시키기 위해 아래와 같이 형변환이 필요합니다.

참고: MyFunction은 interface MyFunction { void method(); }와 같이 정의되었다고 가정합니다.

MyFunction f = (MyFunction)(() -> {}); // 양변의 타입이 다르므로 형변환이 필요

람다식은 MyFunction 인터페이스를 직접 구현하지 않았지만, 이 인터페이스를 구현한 클래스의 객체와 완전히 동일하기 때문에 위와 같은 형변환을 허용합니다. 그리고 이 형변환은 생략이 가능합니다.

람다식은 이름이 없을 뿐 분명히 객체인데도, 아래와 같이 Object타입으로 형변환할 수 없습니다.
람다식은 오직 함수형 인터페이스로만 형변환이 가능합니다.

Object obj = (Object)(() -> {}); // 에러. 함수형 인터페이스로만 형변환 가능

굳이 Ojbect 타입으로 형변환하려면, 먼저 함수형 인터페이스로 변환해야 합니다.

Object obj = (Object)(() -> {}); 
String str = ((Object)(MyFunction)(() -> {})).toString();

이제 예제를 통해 직접 확인을 합니다.

package limdae.dev;

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

public class test {
    public static void main(String[] args) {
        MyFunction f = () -> {}; // MyFunction f = (MyFunction)(() -> {});
        Object object = (MyFunction)(() -> {});
        String string = ((Object)(MyFunction)(() -> {})).toString();
        System.out.println("f = " + f);
        System.out.println("object = " + object);
        System.out.println("string = " + string);

//        System.out.println(() -> {}); // 에러. 람다식은 Object 타입으로 형변환 안됨
        System.out.println((MyFunction)(() -> {}));
//        System.out.println((MyFunction)(() -> {}).toString());
        System.out.println(((Object)(MyFunction)(() -> {})).toString());

    }
}

// 실행 결과
f = limdae.dev.test$$Lambda$1/0x0000024901000bf8@38af3868
object = limdae.dev.test$$Lambda$2/0x0000024901001000@77459877
string = limdae.dev.test$$Lambda$3/0x0000024901001218@5674cd4d
limdae.dev.test$$Lambda$4/0x0000024901001430@72ea2f77
limdae.dev.test$$Lambda$5/0x0000024901001c00@681a9515

실행결과를 보면, 컴파일러가 람다식의 타입을 어떤 형식으로 만들어내는지 알 수 있습니다. 일반적인 익명 객체라면, 객체의 타입이 '외부클래스이름$번호'와 같은 형식으로 타입이 결정되었을텐데, 람다식의 타입은 외부클래스$$Lambda$번호와 같이 형식으로 되어 있는 것을 확인할 수 있습니다.

3.4 외부 변수를 참조하는 람다식

람다식도 익명 객체, 즉 익명 클래스의 인스턴스이므로 람다식에서 외부에 선언된 변수에 접근하는 규칙은 앞서 익명 클래스에서 배운 것과 동일합니다.

package limdae.dev;

@FunctionalInterface
interface MyFunction {
    void myMethod();
}

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

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

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

            MyFunction f = () -> {
//                System.out.println("i = " + i);
                System.out.println("val = " + val);
                System.out.println("this.val = " + ++this.val);
                System.out.println("Outer.this.val = " + ++Outer.this.val);
            };
            f.myMethod();
        }
    } // Inner 클래스의 끝
} // Outer 클래스의 끝

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

// 실행 결과
val = 30
this.val = 21
Outer.this.val = 11

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

반면에 Inner 클래스와 Outer 클래스의 인스턴스 변수인 this.val과 Outer.this.val은 상수로 간주되지 않으므로 값을 변경해도됩니다. 그리고 외부 지역변수와 같은 이름의 람다식 매개변수는 허용되지 않습니다.

참고!

java.util.function 패키지 생략했습니다. 사용하게 될 때 내용을 추가 정리합니다.

4. 메서드 참조

람다식이 하나의 메서드만 호출하는 경우에는 '메서드 참조(Method reference)'라는 방법으로 람다식을 간략히 할 수 있습니다. 예를 들어 문자열을 정수로 변환하는 람다식은 아래와 같이 작성할 수 있습니다.

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

보통 이렇게 람다식을 작성하는데, 이 람다식을 메서드로 표현하면 아래와 같습니다.

참고: 람다식은 엄밀히 말하자면 익명 클래스의 객체이지만 간단히 메서드로 작성했습니다.

Integer wrapper(String s) { // 이 메서드의 이름은 의미없다.
    return Integer.parseInt(s);
}

이 wrapper 메서드는 별로 하는 일이 없습니다. 그저 값을 받아서 Integer.parseInt()에게 넘겨주는 일만 할 뿐입니다. 차라리 이 메서드를 벗겨내고 Integer.parseInt()를 직접 호출하는 것이 낫지 않을까요?

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

참조변수 f의 타입만 봐도 람다식이 두 개의 String 타입의 매개변수를 받는 다는 것을 알 수 있으므로, 람다식의 매개변수들은 없어도 됩니다. 위의 람다식에서 매개변수들을 제거해서 메서드 참조로 변경하면 아래와 같습니다.

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

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

하나의 메서드만 호출하는 람다식은 '클래스이름::메서드이름' 또는 '참조변수::메서드이름'으로 바꿀 수 있다.

4.1 생성자의 메서드 참조

생성자를 호출하는 람다식도 메서드 참조로 변환할 수 있습니다.

Supplier<MyClass> s = () -> new MyClass(); // 람다식
Supplier<MyClass> s = MyClass::new; // 메서드 참조

매개변수가 있는 생성자라면, 매개변수의 개수에 따라 알맞은 함수형 인터페이스를 사용하면 됩니다. 필요하다면 함수형 인터페이스를 새로 정의해야 합니다.

Function<Integer, MyClass> f = (i) -> new MyClass(i); // 람다식
Function<Integer, MyClass> f2 = MyClass::new; // 메서드 참조

BiFunction<Integer, String, MyClass> bf = (i, s) -> new MyClass(i, s); // 람다식
BiFunction<Integer, String, MyClass> bf2 = MyClass::new; // 메서드 참조

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

Function<Integer, int[]> f = x -> new int[x];
Function<Integer, int[]> f2 = int[]::new;

메서드 참조는 람다식을 마치 static 변수처럼 다룰 수 있게 해줍니다. 메서드 참조는 코드를 간략히 하는데 유용해서 많이 사용됩니다. 람다식을 메서드 참조로 변환하는 연습을 많이해서 빨리 익숙해져야 합니다.