[JAVA] 람다식 (Lambda Expression)

자바가 1996년에 처음 등장한 이후로 두 번의 큰 변화가 있었는데, 한번은 JDK 1.5부터 추가된 지네릭스(generics)의 등장이고, 또 한 번은 JDK 1.8부터 추가된 람다식(lambda expression)의 등장이다. 이 두 가지 새로운 변화에 의해 자바는 더 이상 예전의 자바가 아니게 되었다.

특히 JDK 1.8부터 등장한 람다식으로 인해 자바는 객체지향언어인 동시에 함수형 언어가 되었다.

람다식이란?

간단히 말해서 메서드를 하나의 식(expression)으로 표현한 것이다. 함수를 간략하면서도 명확한 식으로 표현할 수 있게 해준다.

이전에 내부 클래스를 정리하면서 익명 함수(anonymous function) 언급할 때 같이 가볍게 살펴봤듯이 람다식도 익명함수이다. 메서드를 람다식으로 표현하면 메서드의 이름이 없어지기 때문이다.

예제

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

위의 람다식으로 표현된 메서드를 따로 만들면 아래와 같다.

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

람다식으로 인해서 간결하고 이해하기 쉬워지며 하나의 메서드를 구현하기 위해서 클래스를 만들어주고 객체도 생성해주어야 하는 번거로운 작업을 생략할 수 있다. 게다가 메서드의 매개변수로 람다식을 통해 메서드를 전달할 수도 있고, 메서드의 결과로 반활될 수도 있다. 즉, 메서드를 변수처럼 다룰 수 있게 된 것이다. 이를 통해 얼마나 간결하고 유연하게 자바를 변화시킬 수 있는지에 대해서 알아보자.

Q. 메서드와 함수의 차이?

A. 전통적으로 프로그래밍에서 함수라는 이름은 수학에서 따온 것임. 수학의 함수와 개념이 유사하기 때문. 그러나 객체지향개념에서는 함수를 객체의 행위나 동작을 읳미하는 메서드라는 용어로 사용. 메서드는 함수와 같은 의미지만, 특정 클래스에 반드시 속해야 한다는 제약이 있기 때문에 기존의 함수와 같은 의미의 다른 용어를 선택해서 사용한 것. 그러나 이제 다시 람다식을 통해 메서드가 하나의 독립적인 기능을 하기 때문에 다시 함수라는 용어를 사용하게 되었음.

람다식 작성하기

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

반환타입 메서드이름(매개변수 선언) {

· · ·

}

반환타입 메서드이름(매개변수 선언) -> {

· · ·

}

예제

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) -> a > b ? a : b

또한 람다식에 선언된 매개변수의 타입은 추론이 가능한 경우 생략 가능하다. (대부분의 경우 생략 가능)

람다식에 반환타입이 없는 이유도 같은 이유다. ( 거의 항상 추론이 가능 ) 다음과 같이.

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

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

괄호 생략 예제

매개변수가 하나뿐인 경우에는 앞의 매개변수를 둘러 싸고 있던 괄호()를 생략할 수 있다. 단, 매개변수의 타입이 명시되어 있으면 생략이 불가능하다.

(a) -> a * a
(int a) -> a * a

아래와 같이 괄호 생략

a -> a * a    // OK
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;

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

예를들어, 다음과 같은 인터페이스가 될 수 있다.

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

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

javaMyInterface f = new MyInterface() {
                    public int max(int a, int b) {
                        return a > b ? a : b;
                    }
                };
 
// 익명 객체의 메서드 호출
int big = f.max(5, 3);    

MyInterface 인터페이스에 정의된 메서드 max()는 람다식과 선언부가 일치한다. 그래서 위 코드의 익명 객체를 람다식으로 대체할 수 있다.

MyInterface f = (int a, int b) -> a > b ? a : b;
 
// 익명 객체의 메서드 호출
int big = f.max(5, 3);    

이처럼 람다식으로 대체 가능한 이유는 람다식도 실제로는 익명 객체이고, MyInterface인터페이스의 메서드 max()와 람다식의 매개변수의 타입과 개수 그리고 반환값이 일치하기 때문이다. 이렇게 하나의 메서드가 선언된 인터페이스를 정의해서 람다식을 다루는 것은 기존의 자바의 규칙들을 어기지 않으면서 자연스럽다 판단하여 인터페이스를 통해 람다식을 다루기로 결정이 되었다고 한다. 그로 인해 어노테이션이 하나 추가되었는데 지난 시간이 잠깐 소개한 함수형 인터페이스(Functional Interface)라는 의미를 명시하는 어노테이션이 등장했다. 

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

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

기존에는 아래와 같이 복잡하게 했어야 했는데

List<String> list = Arrays.asList("abx", "aaa", "bbb", "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", "ddd", "aaa");
Collections.sort(list, (s1, s2) -> s2.compareTo(s1));

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

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

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

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

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

※ 위에서 MyFunction f 라는 참조변수에 람다식을 대입할 때 다음과 같이 형변환이 이루어진다.

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

람다식은 익명 객체이고 익명 객체는 타입이 없다. (더 정확히는 타입이 있긴 있지만 컴파일러가 임의로 이름을 정하기 때문에 알 수 없는 것) 그래서 대입 연산자의 양변의 타입을 일치시키기 위해 위와 같이 형변환이 필요하다.

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

여기서 한가지 더 주의할 점은 람다식은 Object타입으로 형변환 할 수 없다. 오직 함수형 인터페이스로만 형변환이 가능하다. 굳이 Object타입으로 형변환이 필요하다면 먼저 함수형 인터페이스로 변환한 후에 Object타입으로 변환하면 된다.

Object obj = (Object) ( () -> System.out.println("myMethod()") );    // 에러

Object obj = (Object) (MyFunction) ( () -> System.out.println("myMethod()") );

String str = ((Object) (MyFunction) ( () -> System.out.println("myMethod()") ) ).toString();

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

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

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

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

즉, 앞에서 말했듯이 메서드를 변수처럼 주고받는 것이 가능해진 것이다. (사실상 메서드가 아니라 객체를 주고받는 것이라 실제로 달라진 것은 아무것도 없지만, 람다식 덕분에 예전보다 코드가 더 간결하고 이해하기 쉬워짐)

형변환 예제

@FunctionalInterface
interface MyFunction {
    void myMethod();  // public abstract void myMethod();
}
 
class LambdaEx2 {
    public static void main(String[] args)     {
        MyFunction f = ()->{}; // MyFunction f = (MyFunction)(()->{}); 
        Object obj = (MyFunction)(()-> {});  // Object타입으로 형변환이 생략됨
        String str = ((Object)(MyFunction)(()-> {})).toString();
 
        System.out.println(f);
        System.out.println(obj);
        System.out.println(str);
 
//        System.out.println(()->{});    // 에러. 람다식은 Object타입으로 형변환 안됨
        System.out.println((MyFunction)(()-> {}));
//        System.out.println((MyFunction)(()-> {}).toString()); // 에러
        System.out.println(((Object)(MyFunction)(()-> {})).toString());
    }
}
 

[실행 결과]

LambdaEx2$$Lambda$1/531885035@6ce253f1

LambdaEx2$$Lambda$2/135721597@53d8d10a

LambdaEx2$$Lambda$3/142257191@3e3abc88

LambdaEx2$$Lambda$4/245257410@65ab7765

LambdaEx2$$Lambda$5/455659002@eed1f14

실행결과를 보면, 컴파일러가 람다식의 타입을 어떤 형식으로 만들어내는지 알 수 있다. 일반적인 익명 객체라면, 객체의 타입이 

'외부클래스이름$번호' 와 같은 형식으로 타입이 결정되었을 텐데, 람다식의 타입은

'외부클래스이름$$Lambda$번호' 와 같은 형식으로 되어 있는 것을 확인할 수 있다.

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

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

@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클래스의 끝
 
class LambdaEx3 {
    public static void main(String args[]) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.method(100);
    }
}
 

[실행 결과]

             i :100

           val :30

      this.val :21

Outer.this.val :11

※ 일반적으로 익명 객체 내부에서 this는 익명 객체의 참조이지만, 람다식에서 this는 람다식을 실행한 객체의 참조.

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

JDK 1.8 이전에는 final을 명시하지 않으면 컴파일이 되질 않았으나 JDK 1.8부터는 최종적으로 final인 경우 final 표기를 하지 않아도 컴파일이 된다. (한마디로 람다식 안에서는 참조하는 지역변수들이 final을 쓰든 안 쓰든 값을 변경하는 것은 허용되지 않음)

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

그리고 외부 지역변수와 같은 이름의 람다식 매개변수는 사용할 수 없다.

void method(int i) {
    int val=30;
 
    MyFunction f = (i) -> {    // 에러. 외부 지역변수와 이름이 중복됨.
        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);    
    };
}

java.util.function 패키지

대부분의 메서드는 타입이 비슷하고 매개변수가 없거나 한 개 또는 두 개, 반환 값은 없거나 한 개.

지네릭 메서드로 정의하면 매개변수나 반환 타입이 달라도 문제가 되지 않는다. 그래서 java.util.funcation패키지에 일반적으로 자주 쓰이는 형식의 메서드를 함수형 인터페이스로 미리 정의해 놓았다. 매번 새로운 함수형 인터페이스를 정의하지 말고 가능하면 이 패키지의 인터페이스를 활용하는 것이 좋다. 그래야 함수형 인터페이스에 정의된 메서드 이름도 통일되고, 재사용성이나 유지보수 측면에서도 좋다. 자주 쓰이는 가장 기본적인 함수형 인터페이스는 다음과 같다.

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

매개변수와 반환값의 유무에 따라 4개의 함수형 인터페이스가 정의되어 있고, Function의 변형으로 Predicate가 있는데, 반환값이 boolean이라는 것만 빼고 Function과 같다.

조건식의 표현에 사용되는 Predicate

Predicate는 조건식을 람다식으로 표현하는데 사용된다.

[참고] 수학에서 결과로 true 또는 false를 반환하는 함수를 predicate라고 한다.

Predicate<String> isEmptyStr = s -> s.length() == 0;
String s = "";
 
if (isEmptyStr.test(s)) // if (s.length==0)
    System.out.println("s is an empty String");

[실행 결과]

s is an empty String

매개변수가 두 개인 함수형 인터페이스

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

[참고] 매개변수의 타입으로 보통 'T'를 많이 사용하기 때문에 알파벳에서 'T' 다음 문자인 'U', 'V', 'W'를 매개변수의 타입으로 사용하는 것일 뿐 별 다른 의미는 없다.

함수형 인터페이스	메서드	설명
BiConsumer<T,U>	void accept(T t, U u)	두개의 매개변수만 있고, 반환값이 없음
BiPredicate<T,U>	boolean test(T t, U u)	조건식을 표현하는데 사용됨. 매개변수는 둘, 반환값은 boolean
BiFunction<T, U, R>	R apply(T t, U u)	두 개의 매개변수를 받아서 하나의 결과를 반환

두 개 이상의 매개변수를 갖는 함수형 인터페이스가 필요하다면 직접 만들어서 써야한다. 다음과 같이.

@FunctionalInterface
interface TriFunction<T, U, V, R> {
    R apply(T t, U u, V v);
}

UnaryOperator와 BinaryOperator

Function의 또 다른 변형으로 UnaryOperator와 BinaryOperator가 있는데, 매개변수의 타입과 반환타입의 타입이 모두 일치한다는 점만 빼고는 Function과 같다.

[참고] UnaryOperator와 BinaryOperator의 조상은 각각 Function과 BiFunction이다.

함수형 인터페이스	메서드	설명
UnaryOperator<T>	R apply(T t)	Function의 자손, Function과 달리 매개변수와 결과의 타입이 같다.
BinaryOperator<T>	R apply(T t, T t)	BiFunction의 자손, BiFunction과 달리 매개변수와 결과의 타입이 같다.

메서드 참조

람다식을 더욱 간결하게 표현할 수 있는 방법이 있다. 항상 할 수 있는 것은 아니고 람다식이 하나의 메서드만 호출하는 경우에는 '메서드 참조(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);

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

BiFunction<String, String, Boolean> f = String::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

참고자료 : 자바의 정석 3rd