[Day 14 | Java] 람다식(Lambda Expression)

람다식(Lambda Expression)은 자바 8부터 도입된 기능으로, 익명 함수(anonymous function)처럼 사용할 수 있는 간단한 문법입니다. 람다식은 주로 함수형 프로그래밍을 지원하기 위해 제공되었으며, 코드의 가독성을 높이고 간결하게 표현하는 데 유리합니다.

1. 람다식의 기본 개념

람다식은 코드에서 메서드를 별도로 선언하지 않고 한 줄로 함수를 정의할 수 있는 표현식입니다. 메서드를 간단하게 표현할 수 있어 코드가 짧아지고, 가독성이 향상됩니다. 자바에서 람다식은 주로 함수형 인터페이스를 구현하는 데 사용됩니다. 함수형 인터페이스는 단 하나의 추상 메서드만을 가진 인터페이스로, @FunctionalInterface로 선언할 수 있습니다.

람다식의 기본 문법

(parameters) -> expression
(parameters) -> { statements; }

2. 람다식의 장점

• 간결성: 메서드 선언 없이 간단하게 작성할 수 있어 코드가 더 짧아집니다.
• 가독성: 코드의 복잡성이 줄어들어 가독성이 높아집니다.
• 지연 평가: 람다식을 통해 계산이 필요한 시점에 연산을 지연하여 실행할 수 있습니다.

수업코드

단계별 람다식 전개

// 함수형 인터페이스 LambdaInter1 정의
// 단일 추상 메서드 method()를 갖는 인터페이스
public interface LambdaInter1 {
    void method(); // 추상 메서드
}

public class LambdaEx01 {
    public static void main(String[] args) {
        // 1. 익명 내부 클래스를 사용하여 LambdaInter1 인터페이스 구현
        new LambdaInter1() {
            @Override
            public void method() {
                System.out.println("Hello Lambda");
            }
        }.method(); // 구현된 method() 바로 호출

        // 2. 익명 내부 클래스를 사용하여 LambdaInter1 구현 후 참조 변수로 method() 호출
        LambdaInter1 f = new LambdaInter1() {
            @Override
            public void method() {
                System.out.println("Hello Lambda");
            }
        };
        f.method(); // 참조 변수를 통해 method() 호출
        
        // 3. 람다식을 사용하여 LambdaInter1 구현
        // 간결하게 메서드를 구현할 수 있음
        f = () -> { System.out.println("Hello Lambda"); };
        f.method();

        // 4. 람다식을 사용한 더 간단한 표현 - 중괄호 생략 (실행문이 하나일 때만 가능)
        f = () -> System.out.println("Hello Lambda");
        f.method();
    }
}

함수형 인터페이스 @FunctionalInterface

@FunctionalInterface // 함수형 인터페이스임을 명시하는 어노테이션
public interface LambdaInter2 {
    void method1(); // 단 하나의 추상 메서드 - 함수형 인터페이스 조건 충족
    // void method2(); // 두 번째 추상 메서드가 있으면 함수형 인터페이스가 아니므로 오류 발생
}


public class LambdaEx02 {
    public static void main(String[] args) {
        // 익명 내부 클래스를 사용하여 LambdaInter2의 두 메서드 구현
        LambdaInter2 f = new LambdaInter2() {
            @Override
            public void method1() {
                System.out.println("method1");
            }

            @Override
            public void method2() {
                System.out.println("method2");
            }
        };
        f.method1(); // method1 호출
        f.method2(); // method2 호출

        // 오류 발생 - 람다식은 함수형 인터페이스에만 사용 가능
        // LambdaInter2는 두 개의 추상 메서드를 가지고 있으므로 함수형 인터페이스가 아님
        f = () -> {
            System.out.println("method 호출2");
        };
    }
}

public class LambdaEx02 {
    public static void main(String[] args) {
        // 익명 내부 클래스로 LambdaInter2 구현
        LambdaInter2 f = new LambdaInter2() {
            @Override
            public void method1() {
                System.out.println("method1");
            }

            // @Override
            // public void method2() {
            //    System.out.println("method2");
            // }
        };
        f.method1(); // method1 호출
        // f.method2(); // 함수형 인터페이스에 없는 메서드이므로 사용 불가

        // 람다식으로 LambdaInter2 구현
        f = () -> {
            System.out.println("method 호출2");
        };
        f.method1(); // 람다식으로 구현된 method1 호출
    }
}

매개변수가 있는 람다식

@FunctionalInterface // 함수형 인터페이스 어노테이션 - 단 하나의 추상 메서드를 가짐
public interface LambdaInter3 {
    void method(int x); // 매개변수 x를 받아 처리하는 추상 메서드
}

public class LambdaEx03 {
    public static void main(String[] args) {
        // 람다식을 사용하여 LambdaInter3의 메서드 구현
        LambdaInter3 f = (int x) -> {
            System.out.println("method 호출 = " + x);
        };

        // 간단한 람다식 표현 - 매개변수 타입(int) 생략 가능
        f = (x) -> System.out.println("method 호출 = " + x);

        // 메서드 호출 시 매개변수로 값 전달
        f.method(10); // "method 호출 = 10" 출력
    }
}

매개변수가 여러개, 반환값이 있는 람다식

@FunctionalInterface // 함수형 인터페이스 어노테이션 - 단 하나의 추상 메서드를 가짐
public interface LambdaInter4 {
    int method(int x, int y); // 두 개의 int 매개변수를 받아 int 값을 반환하는 메서드
}

public class LambdaEx04 {
    public static void main(String[] args) {
        // 람다식을 사용하여 LambdaInter4의 메서드 구현
        LambdaInter4 f = (x, y) -> { return x + y; }; // x와 y를 더하여 결과 반환

        // 간단한 람다식 표현 - return 키워드와 중괄호 생략 가능
        f = (x, y) -> x + y; // 위와 동일한 동작
        
        // method 메서드를 호출하여 매개변수를 전달하고, 결과 출력
        System.out.println(f.method(10, 20)); // "30" 출력
    }
}

람다식 변환 문제

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

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

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

// lambda

@FunctionalInterface
public interface LambdaArrInter {
    int sumArr(int[] arr);
}

public class LambdaArrEx {
    public static void main(String[] args) {
        LambdaInter6 f = arr -> {
            int sum = 0;
            for (int i : arr) {
                sum += i;
            }
            return sum;
        };
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(f.sumArr(arr));
    }
}

람다식을 매개변수로

@FunctionalInterface // 함수형 인터페이스 어노테이션 - 단일 추상 메서드만 포함
public interface LambdaInter5 {
    void run(); // 매개변수 없이 실행되는 메서드
}

public class LambdaEx05 {
    // LambdaInter5 인터페이스 타입을 매개변수로 받아서 run() 메서드를 실행하는 메서드
    public static void execute(LambdaInter5 f) {
        f.run();
    }

    public static void main(String[] args) {
        // 람다식을 사용하여 LambdaInter5의 run 메서드 구현
        LambdaInter5 f = () -> System.out.println("Hello Lambda");
        
        // execute 메서드를 호출하여 run 메서드 실행
        execute(f); // "Hello Lambda" 출력

        // execute 메서드 호출 시 람다식을 직접 전달
        execute(() -> System.out.println("Hello Lambda")); // "Hello Lambda" 출력
    }
}

람다식을 리턴값으로

@FunctionalInterface // 함수형 인터페이스 어노테이션 - 단일 추상 메서드만 포함
public interface LambdaInter6 {
    void run(); // 매개변수 없이 실행되는 메서드
}

public class LambdaEx06 {
    // LambdaInter6 타입의 람다식을 반환하는 메서드
    public static LambdaInter6 getLambdaInter6() {
        // 람다식으로 LambdaInter6의 run 메서드 구현
        LambdaInter6 f = () -> System.out.println("Hello lambda");
        return f; // 구현된 LambdaInter6 인스턴스 반환
    }

    public static void main(String[] args) {
        // getLambdaInter6 메서드를 호출하여 LambdaInter6 타입 람다식을 반환받음
        LambdaInter6 f = getLambdaInter6();
        
        // 반환된 람다식을 통해 run 메서드 실행
        f.run(); // "Hello lambda" 출력
    }
}