[자바] 람다식

injoon2019·2021년 2월 12일
0

자바

목록 보기
33/34

1. 람다식 (Lambda Expression)

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

람다식이란?

람다식은 간단히 말해서 메서들르 하나의 식으로 표현한 것이다.
메서드를 람다식으로 표현하면 메서드의 이름과 반환값이 없어지므로, 람다식을 '익명 함수(anonymous function)'이라고도 한다.

int[] arr = new int[5];
Arrays.setAll(arr, (i) -> (int)(Math.random()*5)+1);
int method() {
    return (int)(Math.random()*5) + 1;
}

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

람다식은 메서드의 매개변수로 전달되어지는 것이 가능하고, 메서드의 결과로 반환될 수도 있다. 람다식으로 인해 메서드를 변수처럼 다루는 것이 가능해진 것이다.

람다식 작성하기

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

반환타입 메서드이름 (매개변수 선언) {
    문장들
}

~~반환타입 매서드~~ 이름 (매개변수 선언) -> {
    문장들
}


예를 들어 두 값 중에서 큰 값을 반환하는 메서드 max를 람다식으로 변환해보자.
``` java
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) -> {return a > b ? a: b;}
(int a, int b) -> a > b ? a : b

람다식에 선언된 매개변수의 타입은 추론이 가능한 경우는 생략할 수 있는데, 대부분의 경우에 생략가능하다. 람다식에 반환타입이 없는 이유도 항상 추론이 가능하기 때문이다.

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

아래와 같이 선언된 매개변수가 하나뿐인 경우에는 괄호()를 생략할 수 있다. 단, 매개변수의 타입이 있으면 괄호()를 생략할 수 있다.

(a) -> a * a
a -> a * a // OK
(int a) -> a * a
int a -> a * a // 에러

마찬가지로 괄호{} 안의 문자잉 하나일때는 괄호{}를 생략할 수 있다. 이 때 문장의 끝에 ';'를 붙이지 않아야 한다는 것에 주의하자

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

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

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

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

자바에서 모든 메서드는 클래스 내에 포함되어야 하는데, 람다식은 어떤 클래스에 포함되는 것일까? 지금까지 람다식이 메서드와 동등한 것처럼 설명해왔지만, 사실 람다식은 익명 클래스의 객체와 동등하다.

참조변수가 있어야 객체의 메서드를 호출 할 수 있으니까 일단 이 익명 객체의 주소를 f라는 참조변수에 저장해 보자.

타입 f = (int a, int b) -> a > b ? a : b; //참조 변수의 타입은 뭐로 해야할 까?

참조형이니까 클래스 또는 인터페이가 가능하다. 그리고 람다식과 동등한 메서드가 정의되어 있는 것이어야 한다. 그래야만 참조변수로 익명 객체(람다식)의 메서드를 호출할 수 있기 때문이다.

예를 들어 아래와 같이 max()라는 메서드가 정의된 MyFunction 인터페이스가 정의되어 있다고 가정하자.

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

람다식을 다루기 위한 인터페이스를 **'함수형 인터페이스(functional interface)'**라고 부르기로 했다.

@FunctionalInterface
interface MyFunction { //함수형 인터페이스 MyFunction을 정의
    public abstract int max(int a, int b);
}

단, 함수형 인터페이스에는 오직 하나의 추상 메서드만 정의되어 있어야 한다는 제약이 있다. 그래야 람다식과 인터페이스의 메서드가 1:1로 연결될 수 있기 때문이다. 반면에 static 메서드와 default메서드의 개수에는 제약이 없다.

기존에는 아래와 같이 인터페이스의 메서드 하나를 구현하는데도 복잡하게 해야 했는데,

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));

함수형 인터페이스 타입의 매개변수와 반환타입

함수형 인터페이스 MyFunction이 아래와 같이 정의되어 있을 때,

@FunctionalInterface
interface MyFunction {
    void myMethod(); //추상 메서드
}

메서드의 매개변수가 MyFunction 타입이면, 이 메서드를 호출할 때 람다식을 참조하는 참조변수를 매개변수로 지정해야한다는 뜻이다.

void aMethod(MyFunction f) {	// 매개변수의 타입이 함수형 인터페이스
    f.myMethod();	//MyFunction에 정의된 메서드 호출
}
     ...
MyFunction f = () -> System.out.println("myMethod()");
aMethod(f);

또는 참조변수 없이 아래와 같이 직접 람다식을 매개변수로 지정하는 것도 가능하다.

aMethod( () -> System.out.println("myMethod()")); //람다식을 매개변수로 지정

그리고 메서드의 반환타입이 함수형 인터페이스타입이라면, 이 함수형 인터페이스의 추상메서드와 동등한 람다식을 가리키는 참조변수를 반환하거나 람다식을 직접 반환할 수 있다.

MyFunction myMethod() {
    MyFunction f = () -> {};
    return f;   //이 줄과 윗 줄을 한 줄로 줄이면, return () -> {};

람다식을 참조변수로 다룰 수 있다는 것은 메서드를 총해 람다식을 주고받을 수 있다는 것을 의미한다. 즉, 변수처럼 메서드를 주고 받는 것이 가능해진 것이다.

@FunctionalInterface // 함수형 인터페이스
interface MyFunction {
    void run(); //public abstract void run();
}

class LambdaEx1 {
    static void execute (MyFunction f) { // 매개변수의 타입이 MyFunction인 메서드
        f.run();
    }
    
    static MyFunction getMyFunction() { // 반환타입이 MyFunction인 메서드
        MyFunction f = () -> System.out.println("f3.run()");
        return f;
    }
    
    public static void main(String[] args) {
        //람다식으로 MyFunction의 run()을 구현
        MyFunction f1 = () -> System.out.println("f1.run()");
        
        MyFunction f2 = new MyFunction() { //익명 클래스로 run()을 구현
            public void run() { //public을 반드시 붙여야 함
                System.out.println("f2.run()");
            }
        };
        
        MyFuncion f3 = getMyFuncion();
        
        f1.run();
        f2.run();
        f3.run();
        
        execute(f1);
        execute( () -> System.out.println("run()");
    }
}

람다식의 타입과 형변환

함수형 인터페이스로 람다식을 참조할 수 있는 것일 뿐, 람다식의 타입이 함수형 인터페이스의 타입과 일치하는 것은 아니다. 람다식은 익명 객체이고 익명 객체는 타입이 없다. 정확히는 타입은 있지만 컴파일러가 임의로 이름을 정하기 때문에 알 수 없는 것이다. 그래서 대입 연산자의 양변의 타입을 일치시키기 위해 아래와 같이 형변환이 필요하다.

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

MyFuncion은 'interface MyFuncion {void method();}와 같이 정의되었다고 가정하였다.

람다식은 MyFuncion인터페이스를 직접 구현하지 않았지만, 이 인터페이스를 구현한 클래스의 객체와 완전히 동일하기 때문에 위와 같은 형변환을 허용한다. 그리고 이 형변환은 생략가능하다.

람다식은 이름이 없을 뿐 분명히 객체인데도, 아래와 같이 Object 타입으로 형변환 할 수 없다. 람다식은 오직 함수형 인터페이스로만 형변환이 가능하다.

java.util.function 패키지

대부분의 메서드는 타입이 비슷하다. 매개변수가 없거나 한 개 또는 두 개, 반환 값은 없거나 한 개, 게다가 지네릭 메서드로 정의하면 매개변수나 반환타입이 달라도 문제가 되지 않는다. 그래서 java.util.function 패키지에 일반적으로 자주 쓰이는 형식의 메서드를 함수형 인터페이스로 미리 정의해 놓았다. 매번 새로운 함수형 인터페이스를 정의하지 말고, 가능하면 이 패키지의 인터페이스를 활용하는 것이 좋다.

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

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

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

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

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

매개변수의 개수가 2개인 함수형 인터페이스는 이름 앞에 접두사 'Bi'가 붙는다.

두 개 이상의 매개변수를 갖는 함수형 인터페이스가 필요하다면 직접 만들어서 써야한다. 만일 3개의 매개변수를 갖는 함수형 인터페이스를 선언한다면 다음과 같을 것이다.

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

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

컬렉션 프레임웍의 인터페이스에 다수의 디폴트 메서드가 추가되었는데, 그 중의 일부는 함수형 인터페이스를 사용한다. 다음은 그 메서드들의 목록이다.

예제

import java.util.*;

class LambdaEx4 {
    public static void main(String[] args) {
        ArrayList<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.replaceAll(i -> i * 10); //list의 각 요소에 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.print("{" + k + ","+"+v"},"));
        System.out.println();
    }
}

메서드 참조

람다식이 하나의 메서드만 호출하는 경우에는 '메서드 참조(method reference)'라는 방법으로 람다식을 간략히 할 수 있다.

BiFunction<String, String, Boolean> f = (s1, s2) -> s1.equals(s2);
BiFunction<String, String, Boolean> f = String::equals; //메서드 참조

매개변수 s1과 s2를 생략해버리고 나면 equals만 남는데, 두 개의 String을 받아서 Boolean을 반환하는 equals라는 이름의 메서드는 다른 클래스에더 존재할 수 있기 때문에 equals앞에 클래스 이름은 반드시 필요하다.

메서드 참조를 사용할 수 있는 경우가 한 가지 더 잇는데, 이미 생성된 객체의 메서드를 람다식에서 사용한 경우에는 클래스 이름 대신 그 객체의 참조변수를 적어줘야 한다.

MyClass obj = new MyClass();
Function<String, Boolean> f = (x) -> obj.equals(x); //람다식
Funciton<String, Boolean> f2 = obj::equals; //메서드 참조

하나의 메서드만 호출하는 람다식은 '클래스이름::메서드이름' 또는 '참조변수::메서드이름'으로 바꿀 수 있다.

생성자의 메서드 참조

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

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

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

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

그리고 배열을 생성할 때는 아래와 같이 하면 된다.

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

관심 있을 만한 포스트

0개의 댓글