람다식(Lamda expression) 총정리와 활용예제

아래 포스트의 예시 및 내용은 남궁성 저자의 자바의 정석을 많이 참고했다.

 

| 람다식이란

람다식은 간딘히 말해서 메서드를 하나의 '식(expression)'으로 표현한 것이다. 자바 8부터 등장한 개념으로 객체지향언어인 자바에 함수형 활용을 더해주었다. 람다식은 메서드의 매개변수로 전달되어지는 것이 가능하고, 메서드의 결과로 반활될 수도 있다. 람다식으로 인해 메서드를 변수처럼 다루는 것이 가능해진 것이다.

메서드를 람다식으로 표현하면 메서드의 이름과 반환값이 없어지므로 람다식을 '익명함수'라고 하기도 한다. 

 

아래 식에서 (i) -> (int)(Math.random()*5+1) 부분이 람다식이다.

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

 

 

| 람다식 작성법

람다식의 기본형태 메서드에서 이름과 반환타임을 제거하고 매개변수 선언부와 몸통{} 사이에 -> 를 추가한다.

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

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

 

람다식 작성의 기본 규칙은 다음과 같다.

 

1. 기본 구조: (매개변수 목록) -> { 실행문; }
   • 매개변수 목록: 람다식이 받아들이는 매개변수들을 괄호 안에 정의한다. 매개변수의 타입은 생략 가능하며, 컴파일러가 문맥을 통해 유추한다.
     • 다만 (int a, int b) 혹은 ( a, b) 로 생략가능할 분 (int a, b) 처럼 여러 매개변수 중 어느 하나의 타입만 생략할 수는 없다.
   • 화살표(->): 매개변수와 람다식의 몸체를 구분한다.
   • 실행문: 실제 람다식이 수행할 코드 블록. 매개변수를 이용한 연산이나 메서드 호출 등이 포함될 수 있다.
2. 매개변수
   • 매개변수가 하나인 경우, 매개변수를 감싸는 괄호를 생략할 수 있다. 단, 타입을 명시하는 경우는 괄호를 생략할 수 없다.
     • 괄호 생략 : a -> a * a 
     • 타입을 명시할 경우 (int a) -> a * a
   • 매개변수가 없는 경우, 빈 괄호를 사용한다(예: () -> System.out.println("Hello")).
3. 실행문
   • 실행문이 단일 문장인 경우, 중괄호 {}를 생략할 수 있다. 그 문장이 값을 반환하는 경우, return 키워드도 생략할 수 있다
     • 람다 표현식: 두 수의 합을 반환 (중괄호 생략)
       (a, b) -> a + b
   • 실행문이 여러 문장으로 구성된 경우, 중괄호 {}로 감싸야 하며, 반환 값이 있는 경우 return 키워드를 명시해야 한다
     • 람다 표현식: 두 수의 합을 계산 후 반환(여러줄 일 경우 중괄호 생략 불가)
       (a, b) -> {
           int sum = a + b; // 첫 번째 문장: 합계 계산
           return sum;      // 두 번째 문장: 계산된 합계 반환
       }
4. 반환값
   • 람다식에서 값을 반환해야 하는 경우, return 문을 사용한다. 단일 실행문만 있는 경우 return과 중괄호 {}를 생략할 수 있다.
5. 타입 추론
   • 람다식의 매개변수 타입은 생략 가능하다. 컴파일러가 매개변수의 타입을 문맥상 유추할 수 있기 때문이다.
6. 함수형 인터페이스
   • 람다식은 함수형 인터페이스의 구현체로 사용된다. 함수형 인터페이스는 오직 하나의 추상 메소드를 가진 인터페이스를 말한다. @FunctionalInterface 어노테이션을 사용하여 함수형 인터페이스임을 명시할 수 있다.
   • 함수형 인터페이스 : Runnable, Predict, Consumer, Supplier 등

 

| 함수형 인터페이스(Functional Interface)

함수형 인터페이스(Functional Interface)는 오직 하나의 추상 메서드를 가진 인터페이스를 말한다. 자바 8부터 함수형 프로그래밍을 지원하기 위해 도입되었으며, 람다 표현식(Lambda Expression)을 사용하여 이러한 인터페이스의 구현체를 간단하고 명료하게 제공할 수 있다.

 

원칙적으로 자바에서 모든 메서드는 클래스 내에 포함되어야 한다. 그렇다면 람다식은 어떤 클래스에 포함되는 것일까? 람다식이 하나의 메서드로 인식되기 쉽지만 사실 람다식은 익명 클래스의 객체와 동등하다.

 

자바에서 모든 메서드는 클래스의 일부로 존재해야 하기 때문에 표면적으로는 클래스 없이 독립적으로 존재하는 것처럼 보이는 람다 표현식도 내부적으로는 어떤 클래스에 속하는 형태로 변환되어 처리되는 것이다.

 

람다 표현식은 익명 클래스의 객체를 생성하는 것과 유사한 방식으로 작동한다. 익명 클래스는 이름이 없는 클래스로, 주로 일회성으로 사용되는 객체를 생성할 때 사용된다. 

자바 컴파일러는 람다 표현식을 함수형 인터페이스의 익명 구현체로 변환한다. 즉, 람다 표현식은 실행 시점에서 익명 클래스의 인스턴스로 표현되며, 이 인스턴스는 함수형 인터페이스의 단 하나의 추상 메소드를 구현한 것으로 처리된다.

 

아래 예시의 람다 표현식은 Runnable 인터페이스의 run 메소드를 구현하는 익명 클래스의 객체를 생성하는 것과 동등한 작업을 수행한다. 컴파일러는 이 람다 표현식을 익명 클래스의 인스턴스 생성 코드로 변환하는 것이다.

 

// 람다식
Runnable r = () -> System.out.println("Hello, world!");

// 익명 클래스의 인스턴스 생성 코드
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello, world!");
    }
};

 

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

 

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

 

1) 함수형 인터페이스 예시

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

@FunctionalInterface
public interface MyFunctionalInterface {
    // 하나의 추상 메서드만 정의
    void abstractMethod();

    // default 메서드는 여러 개 정의할 수 있음
    default void defaultMethod1() {
        System.out.println("Default method 1");
    }

    default void defaultMethod2() {
        System.out.println("Default method 2");
    }

    // static 메서드도 여러 개 정의할 수 있음
    static void staticMethod1() {
        System.out.println("Static method 1");
    }

    static void staticMethod2() {
        System.out.println("Static method 2");
    }
}

 

 

 

2) 함수형 인터페이스의 매개변수화 반환타입 예시

• 람다식을 참조변수로 다룸으로써 메서드를 통해 람다식을 주고 받을 수 있게다. 즉, 변수처럼 메서드를 주고받는 것이 가능해진 것이다.

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

public class LamdaEx1 {
     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){
         //람다식으로 MyFuntion의 run()을 구현
         MyFunction f1 = () -> System.out.println("f1.run()");

         MyFunction f2 = new MyFunction(){ //익명 클래스로 run()을 구현
             public void run(){ // public 반드시 붙여야함
                 System.out.println("f2.run()");
             }
         };

         MyFunction f3 = getMyFunction();

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

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

     }
}

위 예시의 실행결과

 

 

| 람다식의 타입과 형변환

함수형 인터페이스로 람다식을 참조할 수 있는 것일 뿐, 람다식의 타입이 함수형 인터페이스의 타입과 일치하는 것은 아니다. 람다식은 익명 객체이고 익명 객체는 타입이 없다. 정확히는 타입은 있지만 컴파일러가 임의로 이름을 정하기 때문에 알 수 없다(앞 서 설명한 것 처럼 자바 컴파일러는 람다 표현식을 함수형 인터페이스의 익명 구현체로 변환한다).

그래서 대입 연산자의 양번에 타입을 일치시키기 위해 형변환이 필요하다. 다만 이 형변환의 경우 대부분 생략가능하다.

 

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

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

 

다만, 람다식은 이름이 없을 뿐 분명히 객체인데도, 아래와 같이 Object 타입으로 형변환 할 수 없다. 람다식은 오직 함수형 인터페이스로만 형변환이 가능하다. 람다 표현식은 Object 타입이나 구체적인 클래스 타입으로 직접 형변환 할 수 없다.

이 제약은 람다 표현식이 구현하는 것이 인터페이스의 그 하나의 추상 메서드임을 명확히 하기 위함이다. Object는 하나의 클래스이므로 함수형 인터페이스를 구현한 객체인 람다가 타켓으로 삼을 수 없는 것이다. 또한, Object 타입은 어떤 메서드도 추상 메서드로 가지고 있지 않기 때문에, 람다 표현식의 타겟이 될 수 없다.

 

 

 

만일, 굳이 람다식을 Object 객체로 형변환 하고 싶다면 함수형 인터페이스 타입으로 변환 시킨 수 Object 타입으로 형변환 해야한다.

 

1. 람다 표현식을 함수형 인터페이스 타입으로 변환

먼저, 람다 표현식을 Runnable 인터페이스 타입의 변수에 할당한다. 이렇게 하면 람다 표현식은 Runnable 인터페이스의 구현체로서의 역할을 하게 된다.

2. 함수형 인터페이스 타입을 Object 타입으로 형변환

이제 Runnable 타입의 변수를 Object 타입으로 형변환할 수 있다. 이 단계에서는 Runnable이 이미 구체적인 타입으로 존재하기 때문에, 이를 Object 타입으로 형변환하는 것이 가능하다.

public class LambdaToObjectExample {
    public static void main(String[] args) {
        // 람다 표현식을 함수형 인터페이스 타입으로 변환
        Runnable runnable = () -> System.out.println("Hello, Runnable!");
        
        // 함수형 인터페이스 타입을 Object 타입으로 형변환
        Object obj = (Object) runnable;
        
        // obj를 다시 Runnable 타입으로 형변환하여 사용
        ((Runnable) obj).run();
    }
}

 

 

 

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

예시 코드는 람다식이 자신을 둘러싼 외부 스코프의 변수들을 어떻게 참조하는지 보여주는 예시이다.

람다식 내에서 참조하는 지역변수는 final이 붙지 않았어도 상수로 간주된다.

@FunctionalInterface
interface MyFunction3{
    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; // 에러. 상수의 값을 변경할 수 없음
            MyFunction3 f = () ->{// 메서드 내에서 MyFunction3 타입의 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();

        }
    }
}

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

 

 

• 람다식 내에서 지역변수 i와 val을 참조하고 있으므로 람다식 내에서나 다른  어느 곳에서도 이 변수들의 값을 변경하는 일은 허용되지 않는다.
• 반면에 Inner클래스와 Outer클래스의 인스턴스 변수인 this.val과 Outer.this.val은 상수로 간주되지 않으므로 값을 변경해도 된다.
• 또한 외부 지역변수와 같은 이름의 람다식 매개변수는 허용되지 않는다.