- 람다식 사용법
- 함수형 인터페이스
- Variable Capture
- 메소드, 생성자 레퍼런스
람다식이란?
람다식은 JDK 1.8부터 추가되었다.
람다식은 간단히 말해서 메서드를 하나의 식(expression)으로 표현한 것이다.
람다식은 함수를 간략하면서도 명확한 식으로 표현할 수 있게 해준다.
메서드를 람다식으로 표현하면 메서드의 이름과 반환값이 없어지므로, 람다식을 '익명함수' 라고도 한다.
int[] arr = new int[5];
Arrays.setAll(arr, (i) -> (int)(Math.random()*5)+1);*(i) -> (int)(Math.random()5)+1);
위의 표현식이 람다식이다.
이 람다식이 하는 일을 메서드로 표현하면 다음과 같다.
int method() {
return (int)(Math.random()*5) + 1;
}
모든 메서드는 클래스에 포함되어야 하므로 클래스도 새로 만들어야 하고, 객체도 생성해야만 비로소 이 메서드를 호출할 수 있다. 그러나 람다식은 이 모든 과정없이 오직 람다식 자체만으로도 이 메서드의 역할을 대신할 수 있다.
게다가 람다식은 메서드의 매개변수로 전달되어지는 것이 가능하고, 메서드의 결과로 반환될 수도 있다.
1. 람다식 사용법
예를 들어 두 값 중에서 큰 값을 반환하는 메서드 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) -> {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 //ERROR
마찬가지로 괄호{} 안의 문장이 하나일 때는 괄호{}를 생략할 수 있다. 이 때 문장의 끝에 ';' 을 붙이지 않아야 한다.
(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 //ERROR
람다식 실습
1.
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
2.
void printVar(String name, int i) {
System.out.println(name + "=" + i);
}
//변환
(String name, int i) -> { System.out.println(name + "=" + i); }
(name, i) -> { System.out.println(name + "=" + i); }
(name, i) -> System.out.println(name + "=" + i)
3.
int square(int x) {
return x * x;
}
//변환
(int x) -> x * x
(x) -> x * x
x -> x * x
4.
int roll(){
return (int)(Math.random() * 6);
}
//변환
() -> { 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;
}
2. 함수형 인터페이스(Functional Interface)
람다식은 익명 클래스의 객체와 동등하다.
(int a, int b) -> a > b ? a : b
new Object() {
int max(int a, int b){
return a > b ? a : b;
}
}
제일위의 코드에서 메서드 이름 max는 임의로 붙인 것일 뿐 의미는 없다. 어쨋든 람다식으로 정의된 익명 객체의 메서드를 어떻게 호출할 수 있을 것인가? 이미 알고 있는 것 처럼 참조 변수가 있어야 객체의 메서드를 호출 할 수 있으니까 일단 이 익명 객체의 주소를 f라는 참조변수에 저장해 보자.
타입 f = (int a, int b) -> a > b ? a : b; //참조변수 타입은 뭘로??
그러면, 참조변수 f의 타입은 어떤 것이어야 할까? 참조형이니까 클래스 또는 인터페이스가 가능하다.
그리고 람다식과 동등한 메서드가 정의되어 있는 것이어야 한다. 그래야만 참조변수로 익명 객체(람다식)의 메서드를 호출할 수 있기 때문이다.
예를 들어 아래와 같이 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(lit, 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();
}
static 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()을 구현
@Override
public void run() { //public 을 반드시 붙여야함
System.out.println("f2.run()");
}
};
MyFunction f3 = getMyFunction();
f1.run();
f2.run();
f3.run();
LambdaEx1.execute(f1);
LambdaEx1.execute(() -> System.out.println("run()"));
}
//결과
f1.run()
f2.run()
f3.run()
f1.run()
run()
3. Variable Capture
람다 표현식에서는 익명 함수에서와 마찬가지로, 외부에서 정의된 변수를 활용 할 수 있다.
즉, 람다 표현식에서는 인스턴스 변수, 정적 변수등을 자유롭게 body에서 참조하여 사용할 수 있다.
하지만 지역 변수를 사용하기 위해서는 지역 변수가 반드시 final 로 선언되어 있어야 한다는 제약 조건이 있다.
Supplier<Integer> incrementer(int start) {
return () -> start++;
}
//결과는 컴파일 에러
왜 final 제약 조건을 걸어 두었을까?
인스턴스 변수는 heap영역에 저장이 되고, 지역 변수는 statck 영역에 위치한다.
이런 상황에서 람다가 스레드에서 실행된 후, 변수를 할당한 스레드가 사라져 stack 메모리에서 해제되었으나, 람다를 실행하는 스레드는 살아 있어 해당 변수에 접근을 요청할 케이스가 생긴다.
이와 같은 이유로,실제 변수에 접근을 허용하는 것이 아닌 해당 변수의 복사본을 만들어 그 곳에 접근을 허용하는데 당연히 처음에 복사한 값과 원본의 값이 달라지면 안되기 때문에, 람다에서 접근하는 지역 변수는 final로 선언되어야 한다.
다시말해 외부에 있는 지역변수(=자유변수) 의 복사본을 만들어 접근을 허용하도록 하게 했습니다.
이걸 람다 캡쳐링 (capturing lambda) 이라고 합니다.
캡쳐링했으면 내 마음대로 변경해도 되는거 아냐?라고 할 수 있지만, 리턴된 람다식은 언제 몇 개의 스레드에서 사용될 지 모릅니다.
그 때는 start 값이 '10'으로 복사되어 왔어도 11일지 12일지 그 이상일지를 모릅니다. 결과적으로 final로 처리되지 않으면 자유 변수 참조 값의 동기(Sync)를 맞출 수가 없습니다.
그렇기 때문에 자유 변수를 캡쳐링했을 때는 final 또는 effectively final 변수를 이용해야합니다.
그러면 같은 원리를 스태틱 변수와 인스턴스 변수에 적용해보도록 하겠습니다.
private int start = 0;
Supplier<Integer> incrementer() {
return () -> start++;
}
위 코드는 정상적으로 컴파일되고 start의 경우 인스턴스 변수입니다.
왜 이 경우는 문제가 없다고 판단할까요?
인스턴스 변수는 자바 메모리 구조상 힙 영역에 생성되기 때문에 여러 스레드에서도 동일한 변수를 참조할 수 있기 때문입니다.
그러면 컴파일러는 람다가 가장 최신의 start값(heap영역 안의 값)을 참조하도록 보장할 수 있습니다.
4. 메소드 , 생성자 레퍼런스
메소드 레퍼런스
람다식을 충분히 간결하게 표현했다고 생각했는데 더 간결하게 표현할 수 있는 방법이 있다.
항상 그런 것은 아니고, 람다식이 하나의 메서드만 호출하는 경우에는 '메서드 참조(method reference)' 라는 방법으로 람다식을 간략히 할 수 있다.
예를 들어 문자열을 정수로 변환하는 람다식은 아래와 같이 작성 할 수 있다.
Function<String, Integer> f = (String s) -> Integer.parseInt(s);보통은 이렇게 람다식을 작성하는데, 메서드 레퍼런스를 사용하면 다음과 같다.
Function<String, Integer> f = Integer::paresInt; //메서드 참조
하나 더 예를 들어보자.
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); //람다식
Function<String, Boolean> f2 = obj::equals //메서드 참조
지금 까지 내용을 정리하면 다음과 같다.
종류람다메서드 참조
| 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; //메서드 참조
BiFunction<Intege, String, MyClass> bf = (i,s) -> new MyClass(i,s); //람다식
BiFunction<Intege, String, MyClass> bf = MyClass::new; //메서드 참조
그리고 배열을 생성할 때는 아래와 같이 하면 된다.
Function<Integer, int[]> f = x -> new int[x]; //람다식
Function<Integer, int[]> f2 = int[]::new;
메서드 참조는 람다식을 마치 static변수처럼 다룰 수 있게 해준다. 메서드 참조는 코드를 간략히하는데 유용해서 많이사용된다.
참고 문헌
JAVA의 정석
출처: https://feco.tistory.com/64 [wmJun]
출처: https://jeong-pro.tistory.com/211 [기본기를 쌓는 정아마추어 코딩블로그]
'JAVA' 카테고리의 다른 글
| JAVA 버전별 특징(8, 10, 11) (2) | 2021.05.25 |
|---|---|
| 14주차 : 제네릭 (0) | 2021.03.14 |
| 13주차 : I/O (0) | 2021.03.01 |
| 12주차 : Annotation (애노테이션) (0) | 2021.02.07 |
| 11주차 : enum (0) | 2021.02.07 |
