[Java] 람다식

👩‍🚀 목표

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

👩‍💻 학습할 것

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

 

 

 

람다식 사용법

람다식 Lambda expression

메서드를 하나의 식expression으로 표현한 것

• 함수를 간략하고 명확하게 표현
• 화살표 이용
• 익명 클래스의 객체와 동일하다.

특징

• 0개 이상의 매개변수를 가질 수 있다. 매개 변수의 형식을 명시적으로 선언할 수 있다.
  (int a)와 (a)는 동일하다. : 문맥에서 추정
• 매개 변수는 괄호로 묶이고 쉼표로 구분된다.
  (a, b) 또는 (int a, int b) 또는 (String a int b, float c)
• 빈 괄호 = 매개 변수가 없음
• 단일 매개 변수이고 타입 유추가 가능한 경우 괄호를 사용할 필요가 없다.
  a -> return a*a
• 람다식의 본문에는 0개 이상의 문장이 포함될 수 있다.
• 람다식의 본문은 단일 문장일 경우 중괄호는 없어도 되며, 세미콜론을 생략한다.
  반환 형식은 일반적인 함수와 동일하다.
• 본문에 하나 이상의 문장이 있으면 중괄호 { } 로 묶어야한다.
• 본문에 하나뿐인 문장이 return 문일 경우 괄호{ }를 생략할 수 없다.

작성법

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

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

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

 

2. 반환값이 있는 메서드의 경우 return문 대신 식 expression 으로 대신 할 수 있다.
    식의 연산 결과가 자동적으로 반환값이 된다.
    이때 문장 statement이 아닌 식 expression 이므로 끝에 세미콜론을 붙이지 않는다.

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

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

 

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

     람다식에 반환타입이 없는 이유도 항상 추론이 가능하기 때문이다.

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

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

 

4. 선언된 매개변수가 하나뿐인 경우에는 괄호( )를 생략할 수 있다.

    매개변수의 타입이 있으면 괄호 ( )를 생략할 수 없다.

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

(int a) -> a * a
int a -> a * a    // error

 

5. 괄호 { } 안의 문장이 하나일 때는 괄호 { }를 생략할 수 있다. 문장의 끝에 세미콜론을 붙이지 않아야 한다.

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

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

 

6. 괄호 { } 안의 하나뿐인 문장이 return 일 경우에는 괄호 { }를 생략할 수 없다.

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

 

 

함수형 인터페이스 Functional Interface

자바8에서 도입된 함수형 프로그래밍을 구현하기 위해 Java8부터 도입된 java.util.function 패키지의 일부

• 추상 메소드를 1개만 가지고 있는 인터페이스
• SAM Single Abstract Method 인터페이스
• @FunctionalInterface 어노테이션을 가진 인터페이스
  인터페이스의 목적을 명확하게 전달하고 조건을 충족하지 않을 경우 컴파일러가 오류를 생성할 수 있게 한다.
• default method와 static mehtod는 여러개 존재해도 상관 없다.

메서드 max가 선언된 MyFunction 인터페이스 정의

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

인터페이스를 구현한 익명 클래스 객체

MyFunction f = MyFunction() {
                    public int max(int a, int b) {
                        return a > b ? a : b;
                    }
               };
int big = f.max(5,3);  // 익명 객체의 메서드를 호출

MyFunction 인터페이스에 정의된 메서드 max()는 람다식 '(int a, int b) -> a > b ? a : b' 과 메서드의 선언부가 일치한다.

위 코드의 익명 객체를 람다식으로 아래와 같이 대체할 수 있다.

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

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

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

그래서 인터페이스를 통해 람다식을 다루기로 결정했다.

 

함수형 인터페이스 MyFunction 정의

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

 

함수형 인터페이스에는 오직 하나의 추상 메서드만 정의되어 있어야 한다는 제약이 있다.

람다식과 인터페이스의 메서드가 1:1로 연결될 수 있기 때문이다.

함수형 인터페이스마다 실행 메소드 이름이 다르다.

 

Package java.util.function

 

1) Runnable

인자 🙅‍♀️

반환값 🙅‍♀️

public interface Runnable {
    public abstract void run();
}

Runnable runnable = () -> System.out.println("run");
runnable.run();

run

 

2) Supplier

인자 🙅‍♀️

반환값 T 타입 🙆‍♀️

public interface Supplier<T> {
    T get();
}

Supplier<String> sayHi = () -> "Hello World!";
String str = sayHi.get();
System.out.println(str);

Hello World!

 

3) Consumer

인자 T 타입 🙆‍♀️

반환값 🙅‍♀️

public interface Consumer<T> {
    void accept(T t);
    
    default Consumer<T> andThen(Consumer<? super T> after) {
    	Object.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

 

Consumer<String> makeJuice = fruit -> System.out.println(fruit + " Juice");
makeJuice.accept("Apple");

Apple Juice

 

Consumer<String> makeJuice = fruit -> System.out.println(fruit + " Juice");
Consumer<String> answer = fruit -> System.out.println("--> Love");
makeJuice.andThen(answer).accept("Apple");

Apple Juice
--> Love

 

4) Function

인자 T 타입 🙆‍♀️

반환값 R 타입 🙆‍♀️

public interface Function<T, R> {
    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

 

Function<Integer, Integer> multiply = (value) -> value * 2;
Integer result = multiply.apply(3);
System.out.println(result);

6

 

Function<Integer, Integer> multiply = (value) -> value * 2;
Function<Integer, Integer> add      = (value) -> value + 3;

Function<Integer, Integer> addThenMultiply = multiply.compose(add);

Integer result1 = addThenMultiply.apply(3);
System.out.println(result1);

12

 

5) Predicate

인자 T타입 🙆‍♀️

반환값 boolean 🙆‍♀️ 

public interface Predicate<T> {
    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

test()

Predicate<Integer> isBiggerThanFive = num -> num > 5;
System.out.println("10 is bigger than 5? -> " + isBiggerThanFive.test(10));

10 is bigger than 5? -> true

and() / or()

Predicate<Integer> isBiggerThanFive = num -> num > 5;
Predicate<Integer> isLowerThanSix = num -> num < 6;
System.out.println(isBiggerThanFive.and(isLowerThanSix).test(10));
System.out.println(isBiggerThanFive.or(isLowerThanSix).test(10));

false
true

Predicate<String> isEquals = Predicate.isEqual("Google");
isEquals.test("Google");

true

 

Variable Capture 

람다는 인스턴스 변수와 static 변수, 지역변수를 자유롭게 캡처해서 사용할 수 있다.

인스턴스 변수 : heap에 저장, 쓰레드끼리 공유 가능

static 변수 : 모든 인스턴스에서 공유

지역 변수 : stack에 저장, 쓰레드끼리 공유 불가능

 

람다

인스턴스 변수는 heap에 직접 접근해서 사용

지역 변수에 직접 접근하지 않고, 변수를 stack에 복사해서 사용한다.

 

variable capture

람다에서 파라미터로 넘겨진 변수를 사용하는 것이 아니라 외부에서 선언한 변수를 참조하여 사용하는 것

final 키워드로 작성하거나 effectively final 변수여야 한다.

캡처한 변수를 변경하려고하면 컴파일 오류가 발생한다.

 

final 변수

람다 표현식 내부에서 해당 변수를 변경할 수 없다고 한다.

 

effectively final 변수

람다 표현식 내부에서만 사용되고, 한 번 할당한 후에는 변경되지 않는 변수

람다 표현식에서 해당 변수를 캡처할 때 final을 사용하지 않더라도 final과 동일한 효과를 갖는다. (자바8부터 가능)

 

public void printNumber(int number) {
    int x = 1; // 일반 지역 변수
    int y = 2; // 일반 지역 변수
    int z = 3; // 일반 지역 변수
    int sum = x + y + z + number; // 캡처한 변수 사용

    Consumer<Integer> printer = n -> {
        // x = 100;   // 컴파일 오류
        // y++;       // 컴파일 오류
        // z = z * 2; // 컴파일 오류
        System.out.println(sum); // 캡처한 변수 사용
    };
    printer.accept(number);
}

 

컬렉션이나 배열 변수를 람다 내부에서 변경하는 것은 가능하지만 항상 안전하지는 않다.

다른 쓰레드나 코드에서 동시에 접근 되는 경우 문제가 발생할 수 있다.

 

 

 

메소드 레퍼런스

• 람다식이 하나의 메서드만 호출하는 경우에 람다식을 간략히 할 수 있다.
• 클래스명::메서드명 or 참조변수::메서드명
• 람다식의 일부가 생략되었지만,
• 컴파일러가 생략된 부분을 우변의 parseInt 메서드 선언부로부터, 좌변의 Function 인터페이스에 지정된 지네릭 타입으로부터 쉽게 알아낼 수 있다.

Function<String, Integer> f = (String s) -> Integer.parseInt(s);

// 메서드 참조
Function<String, Integer> f = Integer::parseInt;

 

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> f2 = myClass::new;            // 메서드 참조

Function<Integer, String, MyClass> bf = (i,s) -> new MyClass(i,s);    // 람다식
Function<Integer, String, MyClass> bf2 = myClass::new;                // 메서드 참조

 

 

배열 생성

Function<Integer, int[]> f = x -> new int[x];   // 람다식
Function<Integer, int[]> f2 = int[]::new;       // 메서드 참조

 

 

 

참조

15주차 과제: 람다식

 

남궁성, 자바의 정석 기초편, 도우출판, 2019