[JAVA] 람다식 (Lambda Expression)

/* 람다식이란 */

자바 1.8 부터 사용 가능하다. 동일한 패러미터, 동일한 패러미터 값으로 여러 동작을 하고 싶을 때가 있다.

ex)

동일한 패러미터 : double x, double y,

동일한 패러미터 값 : x = 1.0 , y = 4.0,

여러 동작 x+y , x-y, x/y ...

 

이 경우, 함수를 여럿 만드는 것이 아니라 람다식을 이용한 함수형 프로그래밍을 한다. 데이터 처리의 다형성이라고도 볼 수 있다.

 

코드가 간결해진다. (가독성)

병렬처리 기능을 할 수 있어 멀티쓰레드에 용이하다

 

람다식의 형식은 다음과 같다.

람다식 : (매개변수, ...) -> { 처리문 }

 

먼저 추상 인터페이스를 활용한 람다식이 있다.

 

/* 추상인터페이스 이용1 */

본 코드는, @FunctionalInterface 어노테이션을 사용했다. 필수는 아니지만, 컴파일  과정에서 추상 메소드가 하나 인지 검사해서 정확성을 높여준다.

@FunctionalInterface
public interface Math1 {
    void calculate(int x, int y);
}

 

아래의 코드를 보면 동일한 패러미터 int x , int y,

동일한 패러미터 값 x=1, y=2,

여러 동작 x+y, x-y.

여러 동작을 람다식을 이용한 함수형 프로그래밍을 통해 해결했다.

public class PracticeLambda{
    public static void (String[] args){
        action( (x,y) -> { //람다식1
            int result = x + y; //3
            System.out.println(result);
        });
        
        action( (x,y) -> { //람다식2
            int result = x - y; //1
            System.out.println(result);
        });  
    }
    
    public static void action(Math1 math1){
        int x = 2;
        int y = 1;
        math1.calculate(x,y);
    }
}

 

/* 추상인터페이스 이용2 */

@FunctionalInterface
public interface Math2{
    public int add(int a, int b);
}

 

public class PracticeLambda2 {
    public static void main(String[] args){
        Math2 math2 = (a,b) -> { return a+b; };  // ;가 두개임을 조심하자
        math2.add(10,20); //30
    }
}

 

이와 같이 람다식을 변수로 선언후. 활용도 가능하겠다.

 

/* 추상인터페이스 이용3  (패러미터 없는 경우)*/

@FunctionalInterface
public interface Math3{
    void doTheMath();
}

 

public class Person {
    public void calculate(Math3 math3){
    	math3.doTheMath();
    }
}

 

public class PracticeLambda3 {
    public static void main(String[] args){
        Person person = new Person();
        person.calculate( () -> System.out.println("Okay He or She is calculating rn"));
        //처리문이 하나이면 중괄호 {} 생략 가능
    }
}

 

여기서는 Person 클래스에 Math3를 매개변수로 갖는 calculate() 메소드를 생성했다. 

이 경우를 보면, 자바 코드 실행시 자바의 JVM 이 추적을 해서 PracticeLambda3 -> Person -> Math3의 doTheMath() 함수까지 잘 도달한 것을 알 수 있다.

 

물론 Person 없이도 사용 가능하다. 이때는 앞에 설명한 것 처럼 reference할 수 있는 정적 (static) 메소드를 선언해줘야 한다.

public class PracticeLambda4 {
    public static void main(String[] args){
        action() -> System.out.println("Okay you are calculating rn");
        // 처리문 하나이므로 중괄호 {} 생략가능
    }
    
    public static void action(Math3 math3){
        math3.doTheMath();
    }
}

 

/* 추상인터페이스 이용4  (패러미터 있는 경우)*/

@FunctionalInterface
public interface Math4{
    void doTheMath(String name); //패러미터 추가
}

 

public class Student {
    public void calculate(Math4 math4){
    	math4.doTheMath("JAVA"); //패러미터 추가
    }
}

 

public class PracticeLambda5 {
    public static void main(String[] args){
        Student student = new Student();
        
        student.calculate( (name) -> System.out.println(name + "! are you calculating rn?");
        //처리문이 하나 인경우 중괄호 {} 생략 가능
    }
}

이 경우를 보면, 자바 코드 실행시 자바의 JVM 이 추적을 해서 PracticeLambda5 -> Student -> Math4의 doTheMath() 함수까지 잘 도달한 것을 알 수 있다

 

/* 추상인터페이스 이용5  (리턴값 있는 경우)*/

@FunctionalInterface
public interface Math5{
    int sum(int x, int y); //리턴값이 int
}

 

public class PracticeLambda6 {
    public static void main(String[] args){
        Friend friend = new Friend();
        
        //처리문이 두 개 이상일 경우
        friend.calculate((x,y) -> {
            double value = x+y;
            return value;
        }
        
        //처리문이 하나 일 경우
        friend.calculate((x,y) -> (x+y));  
    }
}

 

/* 추상인터페이스 이용6  (메소드 참조)*/

:: 를 이용한다

@FunctionalInterface
public interface Math6{
    int calculate(int x, int y); //리턴값이 int
}

 

public class Member {
    public void calculate(Math5 math5){
        int answer = math5.calculate(1,2);
        System.out.println("Answer :" + answer);
    }
}

 

public class Calculater {
    public int add(int x, int y) {
        return x+y;
    }
}

 

public class PracticeLambda7 {
    public static void main(String[] args){
        Member membder = new Member();
        
        //인스턴스 메소드
        Calculater calculater = new Calculater();
        
        member.calculate(calcalater :: add);
        
    }
}