[JAVA] 람다식(Lambda Expression)

람다식(Lambda Expression)

JDK1.8부터 추가됨

람다식의 도입 → 자바 = 객체지향 언어 + 함수형 언어

 

※ 객체지향 언어와 함수형 언어란?

각각 객체지향 프로그래밍 패러다임을 지원하는 언어와 함수형 프로그래밍 패러다임을 지원하는 언어

객체지향 패러다임
같은 데이터에 대해 다른 처리 절차(데이터를 처리하는 방식)를 여러 개 명시해야 하는 경우가 자주 발생하는데, 이 때 공통된 데이터를 처리하는 절차를 하나로 묶어 데이터와 여러 절차를 하나의 단위로 다루는 패러다임이다.

함수형 패러다임
주어진 데이터를 값으로 간주하고 새로운 값을 생성하는 함수에 초점을 맞춤으로써 메모리 관리에 대한 부담을 제거한다.

 

1. 람다식이란?

메소드를 하나의 간결한 식(expression)으로 표현한 것

메소드를 람다식으로 표현하면 메소드의 이름과 반환값이 없어지므로 람다식을 '익명 함수(anonymous function)'라고도 한다.

 

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

위 코드에서 ( ) -> (int) (Math.random() * 5) + 1이 바로 람다식이다. 이 람다식이 하는 일을 메소드로 표현하면 다음과 같다.

 

public static int getRandomNum() {
    return (int) (Math.random() * 5) + 1;
}

이렇게 람다식은 클래스, 객체를 생성하고 메소드를 호출할 필요 없이 메소드의 역할을 대신할 수 있다.

또한 람다식은 메소드의 매개변수와 반환값이 될 수 있어 메소드를 변수처럼 다룰 수 있게 한다.

 

※ 메소드와 함수

메소드와 함수는 같은 의미지만 용어를 분리해서 사용했다. Java의 메소드는 객체의 행위, 동작을 의미하며 특정 클래스에 반드시 속해야 한다는 제약이 있다. 그러나 JDK1.8 이후 람다식의 도입으로 메소드가 하나의 독립적인 기능을 하기때문에 익명 함수라는 용어를 사용한다.

 

2. 람다식 작성하기

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

 

ReturnType methodName(Parameter p) {
	// body
}

▼

(Parameter p) -> {
	// body
}

 

# 두 값 중에서 큰 값을 반환하는 메소드 max()를 람다식으로 변환하기

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

▼

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

return문 대신 식(expression)으로 대신할 수 있다. 식의 연산 결과가 자동으로 반환값이 된다. 문장(statement)이 아니므로 끝에 세미콜론(;)은 붙이지 않는다.

▼

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

매개변수의 타입은 추론이 가능한 경우(대부분의 경우) 생략 가능하다. 참고로 반환타입을 제거할 수 있는 이유도 항상 추론 가능하기 때문이다.

▼

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

최종 변환 결과

 

3. 람다식 작성 문법 정리

위 예에서 사용된 작성 규칙 외에도 몇 가지 추가적인 규칙이 존재한다. 그 문법을 정리하면 다음과 같다.

 

1. 기본적인 작성 규칙
- 이름과 반환타입은 작성하지 않는다. (anonymous function)

2. 매개변수
- 추론이 가능한 매개변수의 타입은 생략할 수 있다.
- 단, 매개변수가 두 개 이상일 경우 일부의 타입만 생략하는 것은 허용되지 않는다.
- 선언된 매개변수가 하나인 경우 괄호( )를 생략할 수 있다.
- 단, 매개변수의 타입을 작성한 경우엔 매개변수가 하나라도 괄호( )를 생략할 수 없다.

3. body { }
- return문(return statement) 대신 식(expression)으로 대체할 수 있다.
- 식(expression)의 끝에 세미콜론(;)은 붙이지 않는다.
- 괄호{ } 안의 문장이 하나일 때는 괄호{ }를 생략할 수 있다.
- 이 때, 문장의 끝에 세미콜론(;)은 붙이지 않는다.
- 그러나 return문은 괄호를 생략할 수 없다.

 

4. 메소드 -> 람다식 변환 예제

다음은 메소드를 람다식으로 변환한 예제이다.

 

# 예제 1

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

▼

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

 

# 예제 2

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

▼

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

 

# 예제 3

int square(int x) {
	return x * x;
}

▼

x -> x * x

 

# 예제 4

int roll() {
	return (int) (Math.random() * 6);
}

▼

( ) -> (int) (Math.random() * 6)

 

# 예제 5

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

▼

(int[] arr) -> {
	int sum = 0;
    for(int i: arr) {
    	sum += i;
    return sum;
}

 

5. 함수형 인터페이스(Functional Interface)

함수형 인터페이스는 람다식을 다루는 인터페이스이다. @FunctionalInterface 어노테이션을 사용한다.

람다식은 실제로는 메소드 그 자체가 아니라 익명 클래스의 객체와 동등하다. 익명 객체의 메소드와 람다식의 매개변수, 반환값이 일치하면 익명 객체를 람다식으로 대체할 수 있다.

 

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

MyFunction 인터페이스

 

MyFunction 인터페이스를 구현한 익명 클래스의 객체는 아래와 같이 생성할 수 있다. (기존 방식)

MyFunction f = new MyFunction() {	// MyFunction 인터페이스를 구현한 익명 클래스의 객체 생성
					public int max(int a, int b) {
                    	return a > b ? a : b
                    }
                };
int big = f.max(5, 3);	// 익명 객체의 메소드 호출

그런데 람다식은 익명 객체와 동등하므로 아래와 같이 대체할 수 있다.

▼

MyFunction f = (a, b) -> a > b ? a : b;	// 익명 객체를 람다식으로 대체
int big = f.max(5, 3);	// 익명 객체의 메소드 호출

이렇게 람다식으로 인터페이스의 추상메소드를 구현할 수 있고, 람다식을 참조변수로 다룰 수 있다.

 

- 함수형 인터페이스에는 람다식과 1:1로 연결될 수 있도록 하나의 추상 메소드만 정의해야한다.
- 단, static 메소드와 default 메소드의 개수에는 제약이 없다.

 

※ 람다식 Comparator 인터페이스 compare() 구현 예제

List<String> list = Arrays.asList("abc", "aaa", "bbb", "ddd", "aaa");
Collections.sort(list, new Comparator<String>() {
	public int compare(String s1, String s2) {
    	return s2.compareTo(s1);
    }
});

▼

List<String> list = Arrays.asList("abc", "aaa", "bbb", "ddd", "aaa");
Collections.sort(list, (s1, s2) -> s2.compareTo(s1));

 

# 함수형 인터페이스 타입의 매개변수와 리턴타입

메소드의 매개변수를 함수형 인터페이스 타입으로 선언함으로써

1. 람다식을 참조하는 참조변수를 매개변수로 지정하거나

2. 람다식을 직접 매개변수로 지정할 수 있다.

 

@FunctionalInterface
interface MyFunction {
	void myMethod();
}

class Main {
	static void aMethod(MyFunction f) {	// 함수형 인터페이스 타입의 매개변수
    	f.myMethod();
    }
    
    public static void main(String[] args) {
    	MyFunction f = ( ) -> System.out.println("myMethod()");
        aMethod(f);	// 매개변수 지정 방법1 - 참조변수 지정
        aMethod(( ) -> System.out.println("myMethod()"));	// 매개변수 지정 방법2 - 람다식 직접 지정
    }
}

 

메소드의 리턴타입을 함수형 인터페이스 타입으로 지정함으로써

1. 함수형 인터페이스의 추상 메소드와 동등한 람다식을 가리키는 참조변수를 반환하거나

2. 람다식을 직접 반환할 수 있다.

 

MyFunction myMethod() {
	MyFunction f = ( ) -> { };
    return f;
}

MyFunction myMethod() {
    return ( ) -> { };
}

 

이렇게 람다식을 참조변수로 다룰수 있고 메소드를 통해 람다식을 주고받을 수 있다.

 

# 예제

@FunctionalInterface
interface MyFunction {
    void run();
}

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

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

    public static void main(String[] args) {
        // 1. 익명 클래스로 MyFunction.run() 구현(기존 방식)
        MyFunction f1 = new MyFunction() {
            @Override
            public void run() {
                System.out.println("f2.run()");
            }
        };

        // 2. 람다식으로 MyFunction.run() 구현
        MyFunction f2 = () -> System.out.println("f1.run()");

        // 3. 람다식을 반환하는 메소드 호출
        MyFunction f3 = getMyFunction();

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

        execute(f2);    // 1. 람다식을 참조하는 참조변수를 매개변수로 지정
        execute(() -> System.out.println("run()")); // 2. 람다식을 직접 매개변수로 지정
    }
}

 

6. 람다식의 타입과 형변환

람다식은 익명 객체이고 익명 객체는 타입이 없다.(정확히는 컴파일러가 임의로 이름을 정하기때문에 알 수 없다.) 함수형 인터페이스 타입 참조변수로 람다식을 참조할 수 있는 것일 뿐, 람다식의 타입이 함수형 인터페이스의 타입과 일치하는 것은 아니다.

 

MyFunction f = (MyFunction) (() -> {});

그래서 원래는 위와 같이 형변환이 필요한데, 이는 생략이 가능하다. 람다식이 MyFunction 인터페이스를 직접 구현하지 않지만 인터페이스를 구현한 클래스의 객체와 완전히 동일하기 때문에 이러한 형변환을 허요안다.

 

람다식은 Object 타입으로 형변환할 수 없다. 굳이 하려면 먼저 함수형 인터페이스로 변환해야 한다.

 

Object obj = (Object) (()->{});	// 에러
Object obj = (Object) (MyFunction) (()->{});	// 가능
String str = ((Object) (MyFunction) (()->{})).toString();	// 가능

 

# 예제

@FunctionalInterface
interface MyFunction {
    void myMethod();
}

public class LambdaEx2 {
    public static void main(String[] args) {
        // MyFunction f = (MyFunction) (()->{});
        MyFunction f = ()->{};

        // Object obj = (Object) (MyFunction) (()->{});와 동일. (Object) 생략
        Object obj = (MyFunction) (()->{});

        // String str = ((Object) (MyFunction) (()->{})).toString();와 동일
        String str = ((MyFunction) (()->{})).toString();

        System.out.println(f);
        System.out.println(obj);
        System.out.println(str);

        // 에러. 람다식은 Object 타입으로 형변환 안됨
//        System.out.println(()->{});

        // OK
        System.out.println((MyFunction) (()->{}));

        // 에러
//        System.out.println((MyFunction) (()->{}).toString());

        // OK
        System.out.println(((MyFunction) (()->{})).toString());
    }
}

실행 결과
com.atoz_develop.LambdaEx2$$Lambda$14/0x0000000100066840@6e8dacdf com.atoz_develop.LambdaEx2$$Lambda$15/0x0000000100066c40@7a79be86 com.atoz_develop.LambdaEx2$$Lambda$16/0x0000000100066040@1e643faf com.atoz_develop.LambdaEx2$$Lambda$17/0x0000000100066440@b684286 com.atoz_develop.LambdaEx2$$Lambda$18/0x0000000100065840@3f3afe78

람다식의 타입은 일반적인 익명 객체와 달리 '외부클래스이름$$Lambda$번호'와 같은 형식으로 결정된다.

 

7. 람다식의 외부 변수 참조

@FunctionalInterface
interface MyFunction {
    void myMethod();
}

class Outer {
    int val = 10;   // Outer.this.val

    class Inner {
        int val = 20;   // this.val

        void method(int i) {    // void method(final int i)
            int val = 30;   // final int val = 30;
            // i = 10;  // final 값 변경 불가

            MyFunction 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();
        }
    }
}
public class LambdaEx3 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.method(100);
    }
}

실행 결과
i: 100
val: 30
this.val: 21
Outer.this.val: 11

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

 

반면 Inner클래스와 Outer클래스의 인스턴스 변수인 this.val과 Outer.this.val은 상수로 간주되지 않으므로 값을 변경할 수 있다.

 

void method(int i) {
    int val = 30;

    MyFunction f = (i) -> {	// 에러: 외부 지역변수와 이름 중복
        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();
}

그리고 외부 지역변수와 같은 이름의 람다식 매개변수는 허용되지 않는다.

 

8. java.util.function 패키지

java.util.function 패키지에 자주 쓰이는 형식의 메서드가 함수형 인터페이스로 미리 정의되어 있다. 매번 새로운 함수형 인터페이스를 정의하는 것 보다 이 패키지의 인터페이스를 활용하자.

 

함수형 인터페이스	메소드	설명
java.lang.Runnable	void run()	매개변수도 없고 반환값도 없음
Supplier	T get()	매개변수는 없고 반환값만 있음
Consumer	void accept(T t)	매개변수만 있고 반환값은 없음
Function	R apply(T t)	일반적인 함수. 하나의 매개변수를 받아서 결과를 반환
Predicate	boolean test(T t)	조건식 표현에 사용 매개변수는 하나, 반환 타입은 boolean

표 - 주요 함수형 인터페이스

 

# 조건식의 표현에 사용되는 Predicate

Predicate는 Function의 변형으로 반환타입이 boolean이라는 것만 다르다. 조건식을 람다식으로 표현하는데 사용된다.

 

Predicate<String> isEmptyStr = s -> s.length() == 0;
String s = "";

if(isEmptyStr.test(s)) {
	System.out.println("This is an empty String");
}

 

# 매개변수가 두 개인 함수형 인터페이스

함수형 인터페이스	메소드	설명
BiConsumer<T, U>	void accept(T t, U u)	두 개의 매개변수만 있고 반환값 없음
BiPredicate<T, U>	boolean test(T t, U u)	조건식 표현에 사용 매개변수 둘, 반환값은 boolean
BiFunction<T, U, R>	R apply<T t, U u>	두 개의 매개변수를 받아서 하나의 결과를 반환

 

매개변수가 세 개 이상인 함수형 인터페이스가 필요하면 아래와 같이 직접 만들어야 한다.

 

@FunctionalInterface
interface TriFunction<T, U, V, R> {
	R apply(T t, U u, V v);
}

세 개의 매개변수를 받아서 하나의 결과를 반환하는 함수형 인터페이스 예

 

# UnaryOperator와 BinaryOperator

Function의 또 다른 변형으로 매개변수의 타입과 반환 타입이 일치한다.

 

함수형 인터페이스	메소드	설명
UnaryOperator<T>	T apply(T t)	Function의 자손 매개변수와 리턴값의 타입이 같다.
BinaryOperator<T>	T apply(T t, T t)	BiFunction의 자손 매개변수와 리턴값의 타입이 같다.

 

# 컬렉션 프레임웍과 함수형 인터페이스

컬렉션 프레임웍의 인터페이스에 추가된 디폴트 메소드 중 일부는 함수형 인터페이스를 사용한다.

 

public class LambdaEx4 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for(int i=0; i<10; i++) {
            list.add(i);
        }

        // list의 모든 요소를 출력
        list.forEach(i-> System.out.print(i+","));
        System.out.println();

        // list에서 2 또는 3의 배수 제거
        list.removeIf(x->x%2==0 || x%3==0);
        System.out.println(list);

        // list의 각 요소에 10을 곱한다
        list.replaceAll(i->i*10);
        System.out.println(list);

        Map<String, String> map = new HashMap<>();
        map.put("1", "1");
        map.put("2", "2");
        map.put("3", "3");
        map.put("4", "4");

        // map의 모든 요소를 {k, v}의 형식으로 출력한다.
        map.forEach((k, v)-> System.out.printf("{"+k+","+v+"},"));
        System.out.println();
    }
}

실행 결과
0,1,2,3,4,5,6,7,8,9,
[1, 5, 7]
[10, 50, 70]
{1,1},{2,2},{3,3},{4,4},