JAVA 스터디 20 - 람다식 (Lamda Expression)

람다식이란?

 자바는 원래 OOP 언어이지만 JDK 1.8 부터 함수형 언어의 기능을 포함 했다.

 

람다식의 특징

 

1.함수 (메서드) 를 간단한 식으로 표현하는 방법이다. 

2. 익명함수 (이름 없는 함수 , anonymous function)

일반식 : int max(int a , int b){ return a>b ? a:b;}

람다식 : (int a,int b)->{return a > b ? a : b;}   <-이름이 없다

 

함수와 메서드의 차이

 

- 근본적으로 동일 . 함수는 일반적 용어 , 메서드는 객체지향개념의 용어

- 함수는 클래스에 독립적 , 메서드는 클래스에 종속적

 

람다식의 작성

 

 1. 메서드의 이름과 반환타입을 제거하고 -> 화살표 함수를 블록앞에 추가

람다식 : (int a,int b)->{return a > b ? a : b;}   <-이름이 없다

2. 반환값이 있는 경우 , 식이나 값만 적고 return 문 생략 가능(끝에 ; 안 붙임)

 

람다식 : (int a,int b)-> a > b ? a : b  //a 혹은 b가 반환 타입이 된다

3.매개변수의 타입이 추론 가능하면 생략가능(대부분의 경우 생략 가능하다.)

람다식 : ( a , b )-> a > b ? a : b  //매개 변수 타입이 추론되어 작동한다.

 

람다식 작성 주의점

 

1.매개변수가 하나인 경우 , 괄호() 생략가능 (타입이 없을 때만)

 a -> a * a  //매개변수가 하나 이고 타입이 안적혀있으면 괄호 생략가능
 int a -> a * a   // 타입이 명시되 있음으로 에러

2.메서드 블럭 안에 문장이 하나뿐 일때 , 블럭 { } 생략 가능 (끝에 ';'안 붙임)

(int i) -> {System.out.println(i);} 
(int i) -> System.out.println(i)// 구현구가 한줄이면 블럭 생략가능 이경우 ;을 붙히지 않는다.

 

람다식 예시 

 

public class LamdaExam {

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

    int printVar(String name , int i){
        System.out.println(name + "=" + i);
    }

    //람다
    (name , i) -> System.out.println(name + "=" + i)

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

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

 

람다식은 익명 함수가 아닌 익명객체이다

 

public class LamdaExam {
    public static void main(String[] args) {
        //Object object = (a , b) -> a>b ? a:b

        //위의 람다식은 아래의 익명 객체로 구현된다.

        Object obj = new Object(){
            int max(int a , int b){
                return a>b? a:b;
            }
        };

        //obj.max()를 사용할 수 없다.
        //사용을 위해선 함수형 인터페이스를 선언해야한다.
        int value = obj.max(3,5); 
    }
}

 

함수형 인터페이스

 

 - 단 하나의 추상 메서드만 선언된 인터페이스

 

함수형 인터페이스의 생성과 람다식 구현 

public class FuncInterfaceExam {
    
    //함수형 인터페이스 구현
    static MyFunction f = new MyFunction() {
        @Override
        public int max(int a, int b) {
            return a>b ? a:b;
        }
    };
    //참조 변수가 있어야 사용가능 하다.
    static int value = f.max(4,5);

    //함수형 인터페이스의 람다식 구현

    static MyFunction LamdaF = (a,b)->a>b?a:b;

    static int lamdaValue = LamdaF.max(4,5);

    public static void main(String[] args) {
        System.out.println(value);
        System.out.println(lamdaValue);
    }

}

@FunctionalInterface
interface MyFunction{
    public abstract  int max(int a , int b);
}

메인 메서드에서 바로 사용하기 위해 static 필드와 메서드로 구현했다 .  

함수형 인터페이스를 만드는 방법은  @FunctionalInterface 어노테이션을 붙히고  단 하나의 추상메서드를 갖는 인터페이스를 구현하면된다

 

 메서드 파리미터로의 함수형 인터페이스 사용

public class FuncInterfaceExam {

    //함수형 인터페이스를 메서드의 파라미터로 사용
    static void MyMethod(MyFunction f){
       f.printHello();
    }

    public static void main(String[] args) {

        //추상메서드 람다식으로 구현현
       MyMethod(()-> System.out.println("hello"));
    }

}

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

 

MyMethod는 함수형인터페이스인 MyFuntion을 파라미터로 사용하고 인터페이스의 추상메서드를 실행한다. 

  메인 메서드에서는 MyMethod를 호출하며 MyFunction을 람다로 구현하여 파라미터로 넘겼다.

 

리턴타입으로 함수형 인터페이스 사용

 

public class FuncInterfaceExam {

    //함수형 인터페이스를 반환타입으로 사용
    static MyFunction MyMethod(MyFunction f){
       f.printHello();
       return f;
    }

    public static void main(String[] args) {
        
        //MyFunction 타입으로 반환 하였다.
        MyFunction hello = MyMethod(() -> System.out.println("hello"));
        hello.printHello();
    }

}

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