[JAVA] LAMBDA EXPRESSION - 람다식

 

람다식 : 익명 함수를 이용해서 익명 객체를 생성하기 위한 식

- 인터페이스 함수을 람다식을 사용해서 바로 구현

- 객체를 따로 만들 필요가 없음

- 인터페이스가 갖고 있는 메소드를 간편하고 즉흥적으로 구현하여 사용

- 식별자 없이 실행 가능

 

장점

- 불필요한 클래스 파일이 생기는 것을 막을 수 있음

- 과정이 간결해짐

 

기본 형태

( 타입 매개변수, ... ) -> { 실행문; ... }

- 타입 매개변수 : 오른쪽 중괄호 블록을 실행하기 위해 필요한 값을 제공

- -> 기호 : 매개 변수를 이용해서 중괄호 실행

 

함수적 인터페이스 ( @FunctionalInterface) : 람다식으로 구현 할 인터페이스

- @FunctionalInterface가 적용된 인터페이스는 한 개의 추상 메소드만 선언 가능

  -> 메서드가 없거나 2개 이상일 경우에는 컴파일 오류

 

람다식 형태 1 : 리턴값 없음, 매개 변수 없음

interface Apple {
    void func01();
}

public class LambdaEx01 {
    public static void main(String[] args) {

        //람다식 형태 1
        //람다 자체가 함수
        Apple a = () -> {     
            System.out.println("Apple");            
        };

        a.func01();
    }
}

 

람다식 형태 2 : 리턴값 없음, 매개 변수 있음 (1개)

interface Apple {
    void func01(int num);
}

public class LambdaEx01 {
    public static void main(String[] args) {
        
        //람다식 형태 2 - 인수 전달 (1개)
        Apple a = (num) -> {     
            System.out.println("인수 전달 : " + num);            
        };

        a.func01(10);
        
        //전달 인수가 한.개.일.때.만. ( ) 생략 가능
        //선호
        Apple b = num -> {
            System.out.println("인수 전달 : " + num);
        };
        
        b.func01(20);
        
        //실행 코드가 한.문.장.일.때.만. { } 생략 가능
        Apple c = num -> System.out.print("인수 전달 : " + num);
            
        c.func01(30);
        
    }
}

 

람다식 형태 2 - 1 : 리턴값 없음, 매개 변수 있음 (2개)

interface Apple {
    void func01(int n, String s);
}

public class LambdaEx01 {
    public static void main(String[] args) {
        
        //람다식 형태 2 - 인수 전달 (2개)
        Apple a = (n, s) -> {
            System.out.println("인수 2개 전달 : " + n +", "+ s);
        };
        
        a.func01(10, "TEN");
    }
}

 

람다식 형태 3 : 리턴값 있음, 매개 변수 없음

interface Apple {
    int func01();
}

public class LambdaEx01 {
    public static void main(String[] args) {
        
        //람다식 형태 3 - return 값
        Apple a = () -> {
            return 100;
        };
        
        //{ } 생략하면, return 키워드도 같이 생략해야함
        //선호
        Apple b = () -> 100; //가장 많이 보는 문법
        
        //함수 안에 함수 -> IIFE
//        Apple c = () -> { return (100) -> {
//            return 200;
//        }};
    }
}

 

람다식 형태 4 : 리턴값 있음, 매개 변수 있음 (1개)

interface Apple {
    int func01(int n);
}

public class LambdaEx01 {
    public static void main(String[] args) {
        
        //람다식 형태 4 - 인수 전달, return
        Apple a = (n) -> {
            return 200;
        };
        
        Apple b = n -> 200 + n;
        
        System.out.println(b.func01(1));
    }
}

 

---

 

람다식 변환 순서

1. new B 없애고 ( ) 뒤에 -> 작성

2. public void func01( ) 없애면서 안에 매개 변수가 있으면 ( ) 안에 넣기

3. 구현한 함수를 감싼 { } 제거

package lambda;

interface A {
    void func01();
}

interface B {
    A func02(); // return interface
}

public class LambdaEx02 {
    public static void main(String[] args) {

        B b1 = new B() { // 1번

            @Override
            public A func02() { // 2번, 3번
                return new A() { // 1번
                    public void func01() { // 2번, 3번
                        System.out.println(1);
                    }
                };
            }
        };

        A a1 = b1.func02(); //리턴 값을 받기 위함
        a1.func01();


        //람다식
        B b2 = () -> () -> { System.out.println(2); };
        
        A a2 = b2.func02();
        a2.func01();
    }
}