람다(lambda)

📌 람다식

: 메서드를 하나의 '식(expression)'으로 표현한 것

: 익명함수라고도 함(매서드의 이름X, 반환값X)

 

💁🏻‍♀️ 람다식의 장점

✔️ 클래스를 만들고, 인스턴스를 생성하는 과정을 생략하고 메서드(함수)를 만들 수 있음!

✔️ 메서드를 변수처럼 다룰 수 있음

 

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

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

✔️ 람다식의 매개변수와 반환값의 타입은 추록이 가능한 경우 생략O (대부분의 경우 생략)

✔️ 매개변수가 하나면 (괄호) 생략 가능

✔️ {괄호} 안에 문장이 하나면 (괄호} 생략 가능 (문장 끝에 세미콜론(;)X)

 

 

📌 함수형 인터페이스

: 람다식을 다루기 위한 인터페이스

✔️ 오직 하나의 추상 메서드만 정의 (람다식과 인터페이스를 1:1로 연결하기 위해)

 

💁🏻‍♀️ 람다식을 왜 함수형 인터페이스로 다루죠?

💡 람다식은 사실 메서드와 같은 동등한 것이 아니라 익명 클래스의 객체와 동등

 

🖐🏻 객체지향 Ⅱ에서 익명 클래스를 배웠음

https://uijin.tistory.com/80

객체지향 프로그래밍Ⅱ

 즉,

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

❗ 이 람다식 자체가 익명클래스의 선언 + 인스턴스화 (일회용) → 이게 가능한 이유는 함수형 인터페이스가 오직 1개의 추상메서드를 가지고 있어서!

 

1️⃣ 먼저, 람다식으로 선언된 익명 객체의  메서드를 어떻게 호출할 수 있을까?

    → 일반적으로 객체의 메서드를 호출하려면, 익명 객체의 참조변수가 필요

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

2️⃣ 타입은 어떻게 해야 할까?

    → 참조 변수이므로 클래스 또는 인터페이스가 가능!

    → 즉, 나의 람다식과 일치하는 선언부를 가진 추상메서드를 가지고 있는 인터페이스가 필요! (그래야 타입을 인터페이스로 하고, 해당 추상 메서드를 나의 람다식으로 구현한걸로 생각하고 사용할 수 있으니까!) 

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

MyFunction f = (a, b) -> a > b ? a : b;
f.max(1, 2); // 드디어 람다식을 실제로 사용ㅜㅜ

    → 그래서 등장한 것이 함수형 인터페이스 (ex. 위의 MyFunction 인터페이스)

사실, 위는 다음과 같음 

MyFunction f = new MyFunction() { // MyFunction 인터페이스를 구현한 익명 클래스
                    public int max(int a, int b) {
                        return a > b ? a : b;
                    }
                };

이때, MyFunction이 함수형 인터페이스면 람다식으로 대체가 가능 ❕람다식도 실제로는 익명 객체이기 때문❕

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

 

✔️ 람다식을 메서드의 매개변수와 반환값으로 사용하기

: 해당 메서드의 매개변수 또는 반환값이 함수형 인터페이스 타입이면 람다식 사용가능!

void myMethod(MyFunction f) { ... }
myMethod(() -> System.out.println("MyFunction"));

또는 

MyFunction f = () -> System.out.println("MyFunction"));
myMethod(f);

 

✔️ 람다식의 타입? 함수형 인터페이스 타입?

: 함수형 인터페이스로 람다식을 참조할 수 있는 것일 뿐, 람다식의 타입이 함수형 인터페이스의 타입과 일치하는 것은 아님! (람다식은 익명 객체이고 익명 객체는 타입이 없음! - 정확하게는 타입이 있지만 컴파일러가 임의로 정하기 때문에 알 수 없는 것) but 람다식이 함수형 인터페이스를 직접 구현하진 않았지만, 그 함수형 인터페이스를 구현한 클래스의 객체와 완전히 동일하기 때문에 형변환을 허용!

MyFunction f = (MyFunction) (() -> System.out.println("MyFunction"))); // 명시적 형변환 생략 가능!

❗ 람다식은 오직 함수형 인터페이스로만 형변환이 가능 (Object도 X)

 

✔️ 람다식도 내부 클래스이므로, 람다식 외부에 선언된 변수에 접근하는 규칙이 내부 클래스와 같음!

: 람다식 내에서 참조하는 지역변수는 final이 붙지 않았어도 상수로 간주 (값 변경X)

: 외부 지역변수와 같은 이름의 람다식 매개변수 허용X

 

 

📌 java.util.function 패키지

https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html

Function (Java Platform SE 8 )

: 자주 쓰이는 형식의 메서드를 함수형 인터페이스로 미리 정의해 놓은 패키지

 

💁🏻‍♀️ 함수형 인터페이스를 새로 정의하는 것보다 어떤점이 좋죠?

✔️ 대부분의 메서드는 타입이 비슷함 (매개변수는 0 -2개, 반환값은 0 - 1개)

✔️ 지네릭 메서드로 정의하면 매개변수나 반환 타입이 달라도 문제X

✔️ 함수형 인터페이스에 정의된 메서드 이름이 통일 → 재사용성👍🏻 유지보수👍🏻

 

 

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

❕ 두 개 이상의 매개변수를 갖는 함수형 인터페이스가 필요하면 직접 만들어야 함!

 

✔️ UnaryOperator와 BinaryOperator

 

        함수형 인터페이스             Descripter                 Method

UnaryOperator                    T -> T                   T applay(T t)

BinaryOperator                   (T, T) -> T            T applay(T t, T t)

 

: 매개변수와 반환값의 타입이 모두 일치한다는 점만 제외하고는 Function과 같음

 

✔️ 함수형 인터페이스를 사용하는 컬렉션 프레임워크

 

✔️ 기본형을 사용하는 함수형 인터페이스

: 매개변수 또는 반환값의 타입이 기본형(ex. int, double)을 사용하응 함수형 인터페이스

 

🔗 참고 링크

https://bcp0109.tistory.com/313

Java 8 함수형 인터페이스 (Functional Interface)

 

💁🏻‍♀️ 굳이 기본형을 사용하는 인터페이스를 따로 쓰는 이유가 있나요?

👩🏻‍🏫 원래 기본형 타입의 값을 처리할 때 래퍼 클래스를 사용했지만, 래퍼클래스를 사용하는 것은 비효율적임!

 

        함수형 인터페이스                  Descripter                    Method                                     설명

DoubleToIntFunction                double -> int               int applyAsInt(double d)       AToBFunction은 입력이 A타입 출력이 B타입

TonIntFunction<T>                   T -> int                        int applyAsInt(T value)         ToBFunction은 출력이 B타입이다. 입력은 지네릭타입

IntFunction                                int -> T                        R apply(T t, U u)                   AFunction은 입력이 A타입이고 출력은 지네릭타입

ObjIntConsumer<T>                (T, int) -> void             void accept(T t, U u)            ObjAFunction은 입력이 T, A타입이고 출력은 없음

 

❕ IntToIntFunction이 없는 이유는 IntUnaryOperator가 해당 역할을 할 수 있기 때문! Function<Integer, Integer>이나 IntFunction<Integer>보다 더 효율적임!

 

 

📌 함수형 인터페이스의 합성!

▪️ Function

default <V> Function<T, V> andThen(Function<? super P, ? extends V> after)

default <V> Function<V, R> compose(Function<? super V, ? extends T> before)

static <T> Function<T, V> identity()

Function<String, Integer> f = (s) -> Integer.parsrInt(s, 16);
Function<Integer, String> g = (i) -> Integer.toBinaryString(i);
Function<String, String> h = f.andThen(g); // h("FF")는 g(f("FF"))

❕ identity()는 x -> x인 항등식

 

▪️ Predicate

default Predicate<T>          and(Predicate<? super T> other)

default Predicate<T>         or(Predicate<? super T> other)

default Predicate<T>         negate()

static <T> Predicate<T>    isEqual(Object targetRef)

Predicate<Integer> p = i -> i < 100;
Predicate<Integer> q = i -> i < 200;
Predicate<Integer> r = i -> i%2 == 0;
Predicate<Integer> notP = p.negate(); // i >= 100

Predicate<Integer> all = notP.and(q.or(r)); // all.test(150) 이런식으로 사용 가능!

 

 

📌 메서드 참조

✔️ 람다식이 하나의 메서드만 호출하는 경우 메서드 참조로 람다식을 간략히 할 수 있음!

✔️ 클래스이름::메서드이름 or 참조변수::메서드이름 형식으로 사용!

(String s) -> Integer.parseInt(s); // 기존 람다식
Integer::parseInt // 메서드 참조

x -> obj.equals(x)
obj::equals // 이런 경우 참조변수::메서드이름 형식을 써야함!

✔️ 생성자도 메서드 참조로 변환 가능

() -> new MyClass();
MyClass::new

x -> new int[x]
int[]::new

❕ 매개변수가 있는 생성자라면, 매개변수의 갯수에 따라 알맞은 함수형 인터페이스를 사용! 필요하다면 함수형 인터페이스를 새로 정의!