일상기록
Java - 람다식(Lambda expression) 본문
람다식(Lambda expression)
자바가 1996년에 처음 등장한 이후로 두 번의 큰 변화가 있었다. 한번은 JDK1.5부터 추가된 제네릭(Generics)의 등장이고, 또 한 번은 JDK1.8부터 추가된 람다식(Lambda expression)의 등장이다. 이 두 가지 새로운 변화에 의해 자바는 더 이상 예전의 자바가 아니게 되었다.
특히 람다식의 도입으로 인해, 이제 자바는 객체자향언어인 동시에 함수형 언어가 되었다. 객체지향언어가 함수형 언어의 기능까지 갖추게 하는 일은 결코 쉬운 일이 아니었을텐데도 기존의 자바를 거의 변경하지 않고도 함수형 언어의 장점을 잘 접목시키는데 성공했다.
람다식이란?
람다식(Lambda expression)은 간단히 말해서 메소드를 하나의 '식(expression)'으로 표현한 것이다. 람다식은 함수를 간략하면서도 명확한 식으로 표현할 수 있게 해준다.
메소드를 람다식으로 표현하면 메소드의 이름과 반환값이 없어지므로, 람다식을 '익명함수(anonymous function)'이라고 한다.
int[] arr = new int[5];
Arrays.setAll(arr, (i) -> (int)(Math.random() * 5) + 1);
위 문장의 () -> (int)(Math.random() * 5) + 1이 람다식이다. 이 람다식이 하는 역활을 메소드로 표현하면 다음과 같다.
int method() {
return (int)(Math.random()*5) + 1;
}위의 메소드 보다 람다식이 간결하면서도 이해하기 쉽다는 것에 이견이 없을 것이다. 게다가 모든 메소드는 클래스에 포함되어야 하므로 클래스도 새로 만들어야 하고, 객체도 생성해야만 비로소 메소드 호출이 가능해 진다. 그러나 람다식은 이 모든 과정없이 오직 람다식 자체만으로도 이 메소드의 역활을 대신할 수 있다.
람다식은 메소드의 매개변수로 전달되어지는 것이 가능하고, 메소드의 결과로 반환될 수도 있다. 람다식으로 인해 메소드를 변수처럼 다루는 것이 가능해진 것이다.
Q. 메소드와 함수의 차이는?
A. 전통적인 프로그래밍에서 함수라는 이름은 수학에서 따온 것이다. 수학의 함수와 개념이 유사하기 때문인데 객체지향개념에서는 함수(function)대신 객체의 행위나 동작을 의미하는 메소드(method)라는 용어를 사용한다. 메소드는 함수와 같은 의미이지만, 특정 클래스에 반드시 속해야 한다는 제약이 있기 때문에 기존의 함수와 같은 의미의 다른용어를 선택해서 사용한 것이다. 그러나 이제 다시 람다식을 통해 메소드가 하나의 독립적인 기능을 하기 때문에 함수라는 용어를 사용하게 되었다.
람다식 작성하기
람다식은 '익명 함수'답게 메소드에서 이름과 반환타입을 제거하고 매개변수 선어부와 몸통{} 사이에 '->'를 추가한다 (자바스크립트에선 화살표 함수라 부른다.)
반환타입 메소드이름 (매개변수 선언) {...}
⬇︎반환타입 메서드이름(매개변수 선언) {...}
예를 들어 두 값 중에서 큰 값을 반환하는 메소드 max를 람다식으로 반환하면, 아래와 같이 된다.
int max (int a, int b) {int max(int a, int b) {
return a > b ? a : 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) -> { return a > b a : b; } ➞ (a, b) -> a > b ? a : b (타입 생략시 둘다 생략)
아래와 같이 선언된 매개변수가 하나뿐이 경우에는 괄호()를 생략할 수 있다. 단, 매개변수의 타입이 있으면 괄호()를 생략할 수 없다.
(a) -> a * a a -> a * a
➞
(int a) -> a* a int a -> a * a
마찬가지로 괄호{} 안의 문장이 하나일 때는 괄호{}를 생략할 수 있다. 이 때 문장의 끝에 ';(세미클론)'을 붙이지 않아야 한다는 것에 주의하자.
(String name, int i) -> { (String name, int i) ->
System.out.println(name+""+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)
자바에서 모든 메소드는 클래스 내에 포함되어야 하는데, 람다식은 어떤 클래스에 포함되는 것인가? 지금까지 람다식이 메소드와 동등한 것처럼 설명해왔지만, 사실 람다식은 익명 클래스의 객체와 동등하다.
new Object() {
int max(int a, int b) {
(int a, int b) -> a > b ? a : b ⇄ return a > b ? a : b;
}
}
위의 오른쪽 코드에서 메소드 이름 max는 임의로 붙인 것일 뿐 의미는 없다. 람다식으로 정의된 익명 객체의 메소드를 어떻게 호출할 수 있을까? 이미 알고 있는것 처럼 참조변수가 있어야 객체의 메소드를 호출 할 수 있으니 일단 익명 객체의 주소를 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 bing = f.max(5, 3); // 익명 객체의 메소드 호출이 처럼 MyFunction인터페이스를 구현한 익명 객체를 람다식으로 대체가 가능한 이유는, 람다식도 실제로는 익명 객체이고, MyFunction인터페이스를 구현한 익명 객체의 메소드 max()와 람다식의 매개변수의 타입과 개수 그리고 반환값이 일치해야 하기 때문이다.
지금까지 살펴본 것 처럼, 하나의 메소드가 선언된 인터페이스를 정의해서 람다식을 다루는 것은 기존의 자바의 규칠들을 어기지 않으면서도 자연스럽다. 인터페이스를 통해 람다식을 다루기로 결정되었으며, 람다식을 다루기 위한 인터페이스를 '함수형 인터페이스(Functional Interface)'라고 부르기로 했다.
@FunctionalInterface
interface MyFunction { // 함수형 인터페이스 MyFuntion을 정의
public abstract int max(int a, int b);
}단, 함수형 인터페이스에는 오직 하나의 추상 메소드만 정의되어 있어야 한다는 제약이 있다. 그래야 람다식과 인터페이스의 메소드가 1:1로 연결될 수 있기 때문이다. 반면에 static메소드와 default메소드의 개수에는 제약이 없다.
@FunctionalInterface를 붙이면 컴파일러가 함수형 인터페이스를 올바르게 정의하였는지 확인해주므로 꼭 붙이자.
기존에는 아래와 같이 인터페이스의 메소드 하나를 구현하는데도 복잡하게 해야 했는데
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 f = () -> System.out.println("myMethod()");
aMethod(f);또는 참조변수 없이 아래와 같이 직접 람다식을 매개변수로 저장하는 것도 가능하다.
aMethod(() -> System.out.println("myMethod()"); // 람다식을 매개변수로 저장메소드의 반환타입이 함수형 인터페이스타입이라면, 이 함수형 인터페이스의 추상 메소드와 동등한 람다식을 가르키는 참조변수를 반환하거나 람다식을 직접 반환할 수 있다.
MyFunction myMethod() {
MyFunction f = () -> {};
return f; // 이 줄과 윗 줄을 한 줄로 줄이면, return () -> {};
}람다식을 참조변수로 다룰 수 있다는 것은 메소드를 통해 람다식을 주고받을 수 있다는 것을 의미한다. 즉 변수처럼 메소드를 주고받는 것이 가능해진 것이다.
사실상 메소드가 아니라 객체를 주고받는 것이라 근본적으로 달라진 것은 아무것도 없지만 람다식 덕분에 예전보다 코드가 더 간결하고 이해하기 쉬워졌다.
람다식의 타입과 형변환
함수형 인터페이스로 람다식을 참조할 수 있는 것일 뿐, 람다식의 타입이 함수형 인터페이스의 타입과 일치하는 것은 아니다. 람다식은 익명 객체이고 익명 객체는 타입이 없다. 정확히는 타입은 있지만 컴파일러가 임의로 이름을 정하기 때문에 알 수 없는 것이다. 그래서 대입 연산자의 양변의 타입을 일치시키기 위해 아래와 같이 형변환이 필요하다.
// MyFunction은 'interface MyFunction { void method(); }'와 같이 정의했다고 가정
MyFunction f = (MyFunction)(() -> {}); // 양변의 타입이 다르므로 형변환 필요람다식은 MyFunction인터페이스를 직접 구현하지 않았지만, 이 인터페이스를 구현한 클래스의 객체와 완전히 동일하기 때문에 위와 같이 형변환을 허용한다. 그리고 이 형변환은 생략가능하다.
람다식은 이름이 없을 뿐 분명히 객체인데도, 아래와 같이 Object타입으로 형변환 할 수 없다. 람다식은 오직 함수형 인터페이스로만 형변환이 가능하다.
Object obj = (Object)(() - > {}); // 에러 함수형 인터페이스로만 형변환 가능굳이 Object타입으로 형변환하려면, 먼저 함수형 인터페이스로 변환해야 한다.
Object obj = (Object)(MyFunction)(() -> {});
String srt = (Object)(MyFunction)(() -> {}).toString();print로 확인해보면
실행결과를 보면 컴파일러가 람다식의 타입을 어떤 형식으로 만들어내는지 알 수 있다. 일반적인 익명 객체라면, 객체의 타입이 '외부클래스이름$번호'와 같은 형식으로 타입이 결정되었을 텐데, 람다의 타입은 '외부클래스이름$$Lambda$번호'와 같은 형식으로 되어 있는 것을 확인할 수 있다.
외부 변수를 참조하는 람다식
람다식도 익명 객체, 즉 익명 클래스의 인스턴스이므로 람다식에서 외부에 선언되 변수에 접근하는 규칙은 앞서 익명 클래스에서 배운 것과 동일하다. 아래의 코드는 람다식 내에서 외부에 선어된 변수에 접근하는 방법을 보여준다. 람다식 내에서 참조하는 지역변수는 final이 붙지 않았어도 상수로 간주된다. 람다식 내에서 지역변수 i와 val을 참조하고 있으므로 람다식 내에서나 다른 어느 곳에서도 이 변수들의 값을 변경하는 일은 허용되지 않는다.
반면에 Inner클래스와 Outer클래스의 인스턴스 변수인 this.val과 Outer.this.val은 상수로 간주되지 않으므로 값을 변경해도 된다.
public class A {
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.method(100);
}
@FunctionalInterface
interface MyFunction {
void myMethod();
}
static class Outer {
int val = 10;
class Inner{
int val = 20; // this.val
void method(int i) {
int val = 30; // final int val =30;
// int i = 10; // 에러1 상수의 값을 변경할 수 없음
MyFunction f = () -> { // 에러2 외부 지역변수와 이름이 중복
System.out.println(" i : "+ i);
System.out.println(" value : "+ val);
System.out.println(" this.value : "+ ++this.val);
System.out.println("Outer.this.value : "+ ++Outer.this.val);
};
f.myMethod();
}
}
}
}
void method() {
int val = 30; // final int val =30;
int i = 10; // 에러1 상수의 값을 변경할 수 없음
MyFunction f = (i) -> { // 에러2 외부 지역변수와 이름이 중복
System.out.println(" i : "+ i);
System.out.println(" value : "+ val);
System.out.println(" this.value : "+ ++this.val);
System.out.println("Outer.this.value : "+ ++Outer.this.val);
}외부 지역변수와 같은 이름의 람다식 매개변수는 허용되지 않는다.
'Java' 카테고리의 다른 글
| Java - Function의 합성, Predicate의 결합 (0) | 2023.04.19 |
|---|---|
| java.util.function패키지 (0) | 2023.04.18 |
| Java - 열거형(Enums) (0) | 2023.04.18 |
| Java - 제네릭 타입의 제거 (0) | 2023.04.18 |
| Java - 제네릭 타입의 형변환 (0) | 2023.04.18 |
