[자바/Java] 람다식이란?

github.com/whiteship/live-study/issues/15

15주차 과제: 람다식 · Issue #15 · whiteship/live-study

목표

자바의 람다식에 대해 학습하세요.

학습할 것 (필수)

• 람다식 사용법
• 함수형 인터페이스
• Variable Capture
• 메소드, 생성자 레퍼런스

마감일시

2021년 3월 6일 토요일 오후 1시까지.

---

# 람다식 사용법

 

람다식의 도입으로 인해 자바는 객체지향언어인 동시에 함수형 언어가 되었다.

객체지향언어가 함수형 언어의 기능까지 갖추게 하는 일은 쉽지 않은 일이지만 기존의 자바를 거의 변경하지 않고 함수형 언어의 장점을 잘 접목시키는데 성공헀다. 덕분에 우리는 큰 혼란없이 함수형 언어의 장점들을 자바에서도 누릴 수 있게 되었다.

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

int method(){
	return (int) (Math.random()*5+1;
}

첫번째 코드블럭의 메소드 보다 람다식이 간결하면서 이해하기 쉽다는 것을 바로 알 수있다.

게다가 모든 메소드는 클래스에 포함되어야 하므로 클래스도 새로 만들어야 하고 객체도 생성해야 메소드를 호출할 수 있지만, 람다식은 모든 과정없이 오직 람다식 자체만으로 메소드의 역할을 대신 할 수 있다.

메소드와 함수의 차이는 메소드는 반드시 특정 클래스에 속해야 한다는 제약이 있기 때문에 기존의 함수와는 차이점을 보입니다.

람다식을 작성하는 법은

메소드에서 이름과 반환타입을 제거하고 매개변수 선언부와 몸통{} 사이에 '->'를 추가한다.

// 메소드
반환타입 메소드명 (매개변수 선언) {
    문장
}

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

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

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

 

반환값이 있는 메소드의 경우 return 문 대신 '식' 으로 대신할 수 있다.

문장이 아닌 '식' 이므로 끝에 세미콜론(;)을 붙이지 않는다.

(int a, int b) ->  { a > b ? a : b }

 

매개변수의 타입은 추론이 가능한 경우 생략할 수 있는데, 대부분의 경우 생략이 가능하다.

(a, b) ->  { a > b ? a : b }

선언된 매개변수가 하나일 때는 괄호() 를 생략할 수 있다.

(a) -> a * a
(int a) -> a * a

a -> a * a          // OK.
int a -> a * a      // ERROR.

 

괄호{} 안의 문장이 하나일 때는 괄호{}를 생략할 수 있다.

괄호{} 안의 문장이 return문일 경우 괄호{}를 생략할 수 없다.

(name, i) -> {
    System.out.println(name + "=" + i);
}

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

 

#함수형 인터페이스

 

자바에서 모든 메소드는 클래스 내에 포함되어야 하는데, 람다식은 어떤 클래스에 포함되어야 할까?

람다식은 익명 클래스의 객체와 동등하다.

(int a,int b) -> a>b ? a:b

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

위에서 메소드 이름 max는 임의로 붙인 것일 뿐 의미는 없다.

타입 f = (int a,int b) -> a>b ? a:b

참조변수 f의 타입은 어떤 것이어야 할까?

참조형이니까 클래스 또는 인터페이스가 가능하다. 그리고 람다식과 동등한 메소드가 정의되어 있는 것이어야 한다.

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

위에 인터페이스를 구현한 익명 클래스의 객체는 아래와 같이 생성 할 수 있다.

MyFunction f = new Myfunction() {
                public int max(int a, int b) {
                    return a > b ? a : b;
                }
            };

int big = f.max(5, 3);      //  익명 객체의 메소드 호출

익명 객체를 람다식으로 대체 가능한 이유는 람다식도 실제로는 익명 객체이고, MyFunction 인터페이스를 구현한 익명 객체의 메소드 max()와 람다식의 매개변수 타입과 개수 그리고 반환값이 일치하기 때문이다.

위에서 봤듯이 하나의 메소드가 선언된 인터페이스를 정의해서 람다식을 다루는 것은 기존의 자바 규칙을 어기지 않으면서도 자연스럽다.

그래서 인터페이스를 통해 람다식을 다루기로 결정됐고, 람다식을 다루기 위한 인터페이스를 함수형 인터페이스(functional interface) 라고 부르기로 했다.

 

위에서 설명한 함수형 인터페이스와 람다식 예시이다.

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

public class LambdaEx1 {
    static void execute(MyFunction f) {
        f.run();
    }

    static MyFunction getMyFunction () {
        return () -> System.out.println("f3.run()");
    }

    public static void main(String[] args) {
        MyFunction f1 = () -> System.out.println("f1.run()");

        MyFunction f2 = new MyFunction() {
            @Override
            public void run() {
                System.out.println("f2.run()");
            }
        };

        MyFunction f3 = getMyFunction();

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

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

    }
}

// 결과
f1.run()
f2.run()
f3.run()
f1.run()
run()

# Variable Capture

 

람다식에서 외부 지역변수를 참조하는 행위를 람다 캡쳐링이라고 한다.

람다식도 익명 객체, 즉 익명 클래스의 인스턴스이므로 람다식에서 외부에 선언된 변수에 접근하는 규칙은 익명 클래스에서 배운 것과 동일하다, 아래 에제는 람다식을 사용해서 변경한 것이다.

@FunctionalInterface
interface MyFunction3 {
    void myMethod();
}

class Outer {
    int val = 10;

    class Inner {
        int val = 20;

        void method(int i) {    // void method(final int i)
            int val = 30;   // final int val = 30;
//            i = 10;       // ERROR. 상수의 값은 변경할 수 없다.

            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();
        }
    } // End Of Inner
}   // End Of Outer

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

이 에제는 람다식 내에서 외부에 선언된 변수에 접근하는 방법을 보여준다. 람다식 내에서 참조하는 지역변수는 final이 붙지 않았어도 상수로 간주된다. 람다식 내에서 지역변수 i와 val을 참조하고 있으므로 람다식 내에서나 다른 어느 곳에서도 이 변수들의 값을 변경하는 일은 허용되지 않는다.

 

# 메소드, 생성자 레퍼런스

 

람다식으로 메소드를 이렇게 간결하게 표현 할 수 있다는 것은 굉장히 신선했다. 하지만 람다식을 더욱 간결하게 표현할 수 있는 방법이 있다. 항상 그런 것은 아니지만 람다식이 하나의 메소드만 호출하는 경우에는 메소드 참조 라는 방법으로 람다식을 간략히 할 수 있다.

//보통의 람다식
Function<String, Integer> f = (String s-> Integer.paresInt(s);

//메소드로 표현
Function<String, Integer> f = Integer::parseInt;

람다식의 일부가 생략되었지만 컴파일러는 생략된 부분을 우변의 paresInt 메소드의 선언부로 부터 또는 좌변의 Function인터페이스에 지정된 제네릭 타입으로부터 쉽게 알아낼 수 있다.

참조변수 f의 타입으로 유추하면 람다식이 두 개의 String 타입의 매개변수를 받는다. 따라서, 매개변수 생략가능.

매개변수를 생락하면, equals만 남는데, 두 개의 String을 받아서 Boolean을 반환하는 equals라는 메소드 이므로

 

String::equals로 변경한다.

메소드 참조를 정리하면 아래와 같다.

종류	람다	메소드 참조
static 메소드 참조	x -> ClassName.method(x)	ClassName::method
인스턴스 메소드 참조	(obj, x) -> obj.method(x)	ClassName:method
특정 객체 인스턴스 메소드 참조	x -> obj.method(x)	obj::method

생성자를 호출하는 람다식도 메소드 참조로 변환할 수 있다.

Supplier<MyClass> s = () -> new MyClass();      //  람다식
Supplier<MyClass> s = MyClass:new;              //  메소드 참조

 

 

매개변수가 있는 생성자라면, 매개변수의 개수에 따라 알맞은 함수형 인터페이스를 사용하면 된다.

Function<Integer, MyClass> f = i -> new MyClasS(i);     //  람다식
Function<Integer, MyClass> f = MyClass:new;             //  메소드 참조

BiFunction<Integer, String, MyClass> bf = (i, s) -> new MyClass(i, s);  //  람다식
BiFunction<Integer, String, MyClass> bf = MyClass::new; 

 

메소드 참조 예제

public class MethodReferences {
    public static void main(String[] args) {
//        Function<String, Integer> f = s -> Integer.parseInt(s);
        Function<String, Integer> f = Integer::parseInt;

        System.out.println(f.apply("100") + 200);

        // Supplier 입력 X, 출력 O
//        Supplier<MyClass> s = () -> new MyClass();
        Supplier<MyClass> s = MyClass::new;
        System.out.println(s.get());

        Function<Integer, MyClass> f2 = MyClass::new;
        MyClass m = f2.apply(100);
        System.out.println(m.iv);
        System.out.println(f2.apply(200).iv);

        Function<Integer, int[]> f3 = int[]::new;
        System.out.println(f3.apply(10).length);

    }
}

class MyClass {
    int iv;

    MyClass () {}

    MyClass (int iv) {
        this.iv = iv;
    }
}

 

# Reference

 

자바의 정석(저자. 남궁성)