람다식이란?
메서드를 하나의 식(expression)으로 표현한 것이다. 메서드를 람다식으로 표현하면 메서드의 이름과 반환값이 없어지므로, 람다식을 익명함수라고도 한다.
람다식 도입으로 인해 자바는 객체지향언어인 동시에 함수형 언어가 되었다.
1
2
int[] arr = new int[5];
Arrays.setAll(arr, (i) -> (int)(Math.random() * 5) + 1); // arr=[1,5,2,1,1]
위에 람다식을 메서드로 표현하면 다음과 같다.
1
2
3
int method() {
return (int)(Math.random() * 5) + 1;
}
간결하면서도 이해하기 쉽고, 오직 람다식 자체만으로도 메서드의 역할을 대신할 수 있다. 게다가 메서드의 매개변수로 전달되어지는 것이 가능하고 결과로 반환될 수도 있다.
람다식 작성하기
메서드에서 이름과 반환타입을 제거하고 매개변수 선언부와 몸통{} 사이에 ->를 추가한다.
1
2
3
4
5
6
7
8
9
// 메서드
반환타입 메서드이름(매개변수 선언) {
문장들
}
// 람다식
(매개변수 선언) -> {
문장들
}
예를 들어 메서드 max를 람다식으로 변환하면, 아래의 오른쪽과 같이 된다.
1
2
3
int max(int a, int b) {
return a > b ? a : b;
}
1
2
3
(int a, int b) -> {
return a > b ? a : b;
}
반환값이 있는 메서드의 경우, return문 대신 식(expression)으로 대신 할 수 있다.
1
(int a, int b) -> { return a > b ? a : b; }
1
(int a, int b) -> a > b ? a : b
매개변수의 타입은 추론이 가능한 경우는 생략할 수 있는데, 대부분의 경우에 생략가능하다. 반환타입이 없는 이유도 항상 추론이 가능하기 때문이다.
1
(int a, int b) -> a > b ? a : b
1
(a, b) -> a > b ? a : b
매개변수가 하나뿐인 경우에는 괄호()를 생략할 수 있다. 단, 매개변수 타입이 있으면 생략할 수 없다.
1
2
(a) -> a * a
(int a) -> a * a
1
2
a -> a * a // OK
int a -> a * a // 에러
괄호{}안의 문장이 하나일 때는 괄호{}를 생략할 수 있다. 이 때 세미콜론(;)을 붙이지 않는다.
1
2
3
(String name, int i) -> {
System.out.println(name + "=" + i);
}
1
2
3
(String name, int i) ->
System.out.println(name + "=" + i)
그러나 괄호{}안의 문장이 return문일 경우 생략할 수 없다.
1
2
(int a, int b) -> { return a > b ? a : b; } // OK
(int a, int b) -> return a > b ? a : b; // 에러
아래는 왼쪽 메서드를 오른쪽 람다식으로 변환하는 예제이다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int max(int a, int b) {
return a > b ? a : b;
}
// ====================================
void printVar(String name, int i) {
System.out.println(name + "=" + i);
}
// ====================================
int square(int x) {
return x * x;
}
// ====================================
int roll() {
return (int)(Math.random() * 6);
}
// ====================================
int sumArr(int[] arr) {
int sum = 0;
for(int i : arr)
sum += i;
return sum;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
(int a, int b) -> { return a > b ? a : b; }
(int a, int b) -> a > b ? a : b
(a, b) -> a > b ? a : b
// ====================================
(String name, int i) -> { System.out.println(name + "=" + i); }
(name, i) -> { System.out.println(name + "=" + i); }
(name, i) -> System.out.println(name + "=" + i)
// ====================================
(int x) -> x * x
(x) -> x * x
x -> x * x
// ====================================
() -> { return (int)(Math.random() * 6); }
() -> (int)(Math.random() * 6)
// ====================================
(int[] arr) -> {
int sum = 0;
for(int i : arr)
sum += i;
return sum;
}
함수형 인터페이스(Functional Interface)
람다식은 익명 클래스의 객체와 동등하다.
1
2
(int a, int b) -> a > b ? a : b
1
2
3
4
5
new Object() {
int max(int a, int b) {
return a > b ? a : b;
}
}
예를 들어 MyFunction인터페이스가 정의되어 있고, 이 인터페이스를 구현한 익명 클래스를 생성했다.
1
2
3
4
5
6
7
8
9
10
11
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); // 익명 객체의 메서드를 호출
위 코드의 익명 객체를 람다식으로 대체할 수 있다.
1
2
3
Myfunction f = (int a, int b) -> a > b ? a : b; // 익명 객체를 람다식으로 대체
int big = f.max(5, 3); // 익명 객체의 메서드를 호출
이처럼 익명 객체를 람다식으로 대체가 가능한 이유는 람다식도 실제로는 익명 객체이기 때문이다.
람다식을 다루기 위한 인터페이스를 함수형 인터페이스(functional interface)라고 부르기로 했다.
함수형 인터페이스에는 오직 하나의 추상 메서드만 정의되어 있어야 한다는 제약이 있다. 반면에 static메서드와 default메서드의 개수에는 제약이 없다.
@FunctionalInterface를 붙이면 컴파일러가 함수형 인터페이스를 올바르게 정의했는지 알려준다.
1
2
3
4
5
6
7
@FunctionalInterface
interface MyFunction {
void myMethod(); // 추상 메서드
void myMethod2(); // 에러! 추상메서드는 하나만 정의
static void myMethod3(); // static 메서드
default void myMethod3(); // default 메서드
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@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()");
// 익명클래스로 run()을 구현
MyFunction f2 = new MyFunction() {
public void run() { // public을 반드시 붙여야 함
System.out.println("f2.run()");
}
};
MyFunction f3 = getMyFunction();
f1.run();
f2.run();
f3.run();
execute(f1);
execute( () -> System.out.println("run()") );
}
}
/*
[실행결과]
f1.run()
f2.run()
f3.run()
f1.run()
run()
*/
람다식의 타입과 형변환
람다식은 익명 객체이고 익명 객체는 타입이 없다. 그래서 아래와 같이 형변환이 필요하다. (생략가능)
람다식은 객체인데도 Object타입으로 형변환 할 수 없다. 오직 함수형 인터페이스로만 형변환이 가능하다.
굳이 Object타입으로 형변환하려면, 먼저 함수형 인터페이스로 변환해야 한다.
1
2
3
4
5
6
7
8
9
10
11
interface MyFunction {
void method();
}
MyFunction f = (MyFunction)(()->{}); // 양변의 타입이 다르므로 형변환이 필요
MyFunction f = (()->{}); // 이 형변환은 생략이 가능하다.
Object obj = (Object)(()->{}); // 에러. 함수형 인터페이스로만 형변환 가능
Object obj = (Object)(MyFunction)(()->{});
String str = ((Object)(MyFunction)(()->{})).toString();
외부 변수를 참조하는 람다식
람다식도 익명 객체, 즉 익명 클래스의 인스턴스이므로 외부 변수를 참조하는 규칙은 익명 클래스와 동일하다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
@FunctionalInterface
interface MyFunction {
void myMethod();
}
class Outer {
int val = 10; // Outer.this.val
class Inner {
int val = 20; // this.val
void method(int i) { // void method(final int i) {
int val = 30; // final int val = 30;
// i = 10; // 에러. 상수의 값을 변경할 수 없음.
// MyFunction f = (i) -> { // 에러. 외부 지역변수와 같은 이름의 람다식 매개변수는 허용 안됨.
MyFunction f = () -> {
System.out.println(" i : " + i);
System.out.println(" val : " + val);
System.out.println(" this.val : " + ++this.val);
System.out.println("Outer.this.val : " + ++Outer.this.val);
};
f.myMethod();
}
}
}
class LambdaEx3 {
public static void main(String[] args) {
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.method(100);
}
}
/*
[실행결과]
i : 100
val : 30
this.val : 21
Outer.this.val : 11
*/
람다식 내에서 참조하는 지역변수는 final이 붙지 않았어도 상수로 간주된다. 위 예제에서 람다식 내에서 지역변수 i와 val를 참조하고 있으므로 상수로 간주된다.
반면에 this.val과 Outer.this.val은 상수로 간주되지 않으므로 값을 변경해도 된다.
그리고 외부 지역변수(i)와 같은 이름의 람다식 매개변수는 허용되지 않는다.
java.util.function패키지
대부분의 메서드 타입은 비슷하다. 매개변수가 없거나 한 개 또는 두 개, 반환 값은 없거나 한 개. 게다가 지네릭 메서드로 정의하면 매개변수나 반환 타입이 달라도 문제가 되지 않는다. 그래서 java.util.function패키지에 자주 쓰이는 형식의 메서드를 함수형 인터페이스로 미리 정의해 놓았다.
매번 새롭게 정의하지 말고 가능하면 이 패키지의 인터페이스를 활용하는 것이 좋다.
그래야 메서드 이름도 통일되고, 재사용성이나 유지보수 측면에서도 좋다.
기본적인 함수형 인터페이스
| 함수형 인터페이스 | 메서드 | 설명 |
|---|---|---|
| java.lang.Runnable | void run() | 매개변수도 없고, 반환값도 없음. |
| Supplier | T get() | 매개변수는 없고, 반환값만 있음. |
| Consumer | void accept(T t) | 매개변수만 있고, 반환값이 없음. |
| Function<T, R> | R apply(T t) | 일반적인 함수. 하나의 매개변수를 받아서 하나의 결과를 반환 |
| Predicate | boolean test(T t) | 조건식을 표현하는데 사용됨. 매개변수는 하나, 반환 타입은 boolean |
타입 문자 T는 Type을 R은 Return Type을 의미한다.
매개변수가 두 개인 함수형 인터페이스
| 함수형 인터페이스 | 메서드 | 설명 |
|---|---|---|
| BiConsumer<T, U> | void accept(T t, U u) | 두개의 매개변수만 있고, 반환값이 없음 |
| BiFunction<T, U, R) | R apply(T t, U u) | 두 개의 매개변수를 받아서 하나의 결과를 반환 |
| BiPredicate<T, U> | boolean test(T t, U u) | 조건식을 표현하는데 사용됨. 매개변수는 둘. 반환 타입은 boolean |
두 개 이상의 매개변수를 갖는 함수형 인터페이스가 필요하다면 직접 만들어서 써야한다.
UnaryOperator와 BinaryOperator
Function의 또 다른 변형으로 매개변수 타입과 반환 타입이 모두 일치한다.
| 함수형 인터페이스 | 메서드 | 설명 |
|---|---|---|
| UnaryOperator | T apply(T t) | Function의 자손. Function과 달리 매개변수와 결과의 타입이 같아. |
| BinaryOperator | T apply(T t, T t) | BiFunction의 자손. BiFunction과 달리 매개변수와 결과의 타입이 같다. |
컬렉션 프레임웍과 함수형 인터페이스
컬렉션 프레임웍의 인터페이스에 다수의 디폴트 메서드가 추가되었는데, 그 중의 일부는 함수형 인터페이스를 사용한다.
| 인터페이스 | 메서드 | 설명 |
|---|---|---|
| Collection | boolean removeIf(Predicate | 조건에 맞는 요소를 삭제 |
| List | void replaceAll(UnaryOperator | 모든 요소를 변환하여 대체 |
| Iterable | void forEach(Consumer | 모든 요소에 작업 action을 수행 |
| Map | V compute(K key, BiFunction<K, V, V> f) | 지정된 키의 값에 작업 f를 수행 |
| V computeIfAbsent(K key, Function<K, V> f) | 키가 없으면, 작업 f 수행 후 추가 | |
| V computeIfPresent(K key, BiFunction<K, V, V> f) | 지정된 키가 있을 때, 작업 f 수행 | |
| V merge(K key, V value, BiFunction<V, V, V> f) | 모든 요소에 병합작업 f를 수행 | |
| void forEach(BiConsumer<K, V> action) | 모든 요소에 작업 action을 수행 | |
| void replaceAll(BiFunction<K, V, V> f) | 모든 요소에 치환작업 f를 수행 |
위에 메서드들을 어떤 식으로 사용하는지 다음의 예제를 보면 알 수 있다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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의 각 요소에 10을 곱한다.
list.replaceAll(i -> i * 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();
}
}
/*
[실행결과]
0,1,2,3,4,5,6,7,8,9,
[1, 5, 7]
[10, 50, 70]
{1, 1}, {2, 2}, {3, 3}, {4, 4},
*/
아래 예제는 앞서 공부한 함수형 인터페이스들을 사용하는 예제이다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import java.util.function.*;
import java.util.*;
class LambdaEx5 {
public static void main(String[] args) {
Supplier<Integer> s = () -> (int)(Math.random() * 100) + 1;
Comsumer<Integer> c = i -> System.out.print(i + ", ");
Predicate<Integer> p = i -> i % 2 == 0;
Function<Integer, Integer> f = i -> i / 10 * 10; // i의 일의 자리를 없앤다.
List<Integer> list = new ArrayList<>();
makeRandomList(s, list);
System.out.println(list);
printEvenNum(p, c, list);
List<Integer> newList = doSomething(f, list);
System.out.println(newList);
}
static <T> List<T> doSomething(Function<T, T> f, List<T> list) {
List<T> newList = new ArrayList<T>(list.size());
for(T i : list) {
newList.add(f.apply(i));
}
return newList;
}
static <T> void printEvenNum(Predicate<T> p, Consumer<T> c, List<T> list) {
System.out.print("[");
for(T i : list) {
if(p.test(i))
c.accept(i);
}
System.out.println("]");
}
static <T> void makeRandomList(Supplier<T> s, List<T> list) {
for(int i = 0; i < 10; i++) {
list.add(s.get());
}
}
}
/*
[실행결과]
[20, 69, 25, 80, 16, 45, 46, 3, 3, 75]
[20, 80, 16, 46, ]
[20, 60, 20, 80, 10, 40, 40, 0, 0, 70]
*/
기본형을 사용하는 함수형 인터페이스
오토박싱&언방식으로 인해 기본형 타입 대신 래퍼(wrapper)클래스를 사용하는 것이 비효율적이기 때문에 아래 함수형 인터페이스가 제공된다.
| 함수형 인터페이스 | 메서드 | 설명 |
|---|---|---|
| DoubleToIntFunction | int applyAsInt(double d) | AToBFunction은 입력 A타입, 출력 B타입 |
| ToIntFunction | int applyAsInt(T value) | ToBFunction은 입력 지네릭타입, 출력 B타입 |
| IntFunction | R apply(int value) | AFunction은 입력 A타입, 출력 지네릭타입 |
| ObjIntConsumer | void accept(T t, int i) | ObjAFunction은 입력 T, A타입, 출력 없음 |
Function대신 IntFunction을 사용할 수도 있지만 IntUnaryOperator가 Function이나 IntFunction보다 오토방식&언박싱의 횟수가 즐어들어 더 성능이 좋다.
Function의 합성과 Predicate의 결합
java.util.function패키지의 함수형 인터페이스에는 추상메서드 외에도 디폴트메서드와 static메서드가 정의되어 있다.
Function의 합성
수학에서 두 함수를 합성해서 하나의 새로운 함수를 만들어낼 수 있다는 것처럼, 두 람다식을 합성해서 새로운 람다식을 만들 수 있다.
두 함수의 합성은 어느 함수를 먼저 적용하느냐에 따라 달라진다. 함수 f, g가 있을 떄, f.andThen(g)는 함수 f를 먼저 적용하고, 그 다음에 함수 g를 적용한다. 그리고 f.compose(g)는 반대로 g를 먼저 적용하고 f를 적용한다.
문자열을 숫자로 변환하는 함수 f와 숫자를 2진 문자열로 변환하는 함수 g를 andThen()으로 합성하여 새로운 함수 h를 만들어낼 수 있다.
1
2
3
4
5
Function<String, Integer> f = (s) -> Integer.parseInt(s. 16); // s를 16진수로 인식
Function<Integer, String> g = (i) -> Integer.toBinaryString(i);
Function<String, String> h = f.andThen(g);
System.out.println(h.apply("FF")); // "FF" -> 255 -> "11111111"
이번엔 compose()를 이용해서 반대의 순서로 합성해보자.
1
2
3
4
5
Function<Integer, String> g = (i) -> Integer.toBinaryString(i); // i를 2진 문자열로 변환
Function<String, Integer> f = (s) -> Integer.parseInt(s. 16); // s를 16진수로 인식해서 변환
Function<Integer, Integer> h = f.compose(g);
System.out.println(h.apply(2)); // 2 -> "10" -> 16
그리고 identity()는 항등 함수가 필요할 때 사용한다. 이 함수를 람다식으로 표현하면 x -> x이다.
1
2
3
4
Function<String, String> f = x -> x;
// Funciont<String, String> f = Function.identity(); // 위의 문장과 동일
System.out.println(f.apply("AAA")); // AAA가 그대로 출력됨
항등 함수는 잘 사용되지 않는 편이며, 변환없이 그대로 처리하고자할 때 사용된다.
Predicate의 결합
| 여러 조건식을 논리 연산자인 &&(and), | (or), !(not)으로 연결해서 하나의 식을 구성할 수 있는 것처럼, 여러 Predicate를 and(), or(), negate()로 연결해서 하나의 새로운 Predicate로 결합할 수 있다. |
1
2
3
4
5
6
7
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); // 100 <= i && i < 200 || i % 2 == 0
System.out.println(all.test(150)); // true
이처럼 and(), or(), negate()로 여러 조건식을 하나로 합칠 수 있다. 람다식을 직접 넣어도 된다.
그리고 static메서드인 isEqual()은 두 대상을 비교하는 Predicate를 만들 때 사용한다.
1
2
3
4
5
Predicate<String> p = Predicate.isEqual(str1);
boolean result = p.test(str2); // str1과 str2가 같은지 비교하여 결과를 반환
// 위의 두 문장을 합치면
boolean result = Predicate.isEqual(str1).test(str2) // str1과 str2가 같은지 비교
메서드 참조
람다식이 하나의 메서드만 호출하느 경우에는 메서드 참조(method reference)라는 방법으로 람다식을 간략히 할 수 있다.
예를 들어 문자열을 정수로 변환하는 람다식은 아래와 같이 작성할 수 있다.
1
2
3
4
5
6
7
8
9
Function<String, Integer> f = (String s) -> Integer.parseInt(s); // 람다식
Function<String, Integer> f2 = Integer::parseInt; // 메서드 참조
BiFunction<String, String, Boolean> f = (s1, s2) -> s1.equals(s2); // 람다식
BiFunction<String, String, Boolean> f2 = String::equals; // 메서드 참조
MyClass obj = new MyClass();
Function<String, Boolean> f = (x) -> obj.equals(x); // 람다식
Function<String, Boolean> f2 = obj::equals; // 메서드 참조
위에 3가지 경우의 메서드 참조를 정리하면 다음과 같다.
| 종류 | 람다 | 메서드 참조 |
|---|---|---|
| static메서드 참조 | (x) -> ClassName.method(x) | ClassName::method |
| 인스턴스메서드 참조 | (obj, x) -> obj.method(x) | ClassName::method |
| 특정 객체 인스턴스메서드 참조 | (x) -> obj.method(x) | obj::method |
하나의 메서드만 호출하는 람다식은 클래스이름::메서드이름 또는 참조변수::메서드이름으로 바꿀 수 있다.
생성자의 메서드 참조
생성자를 호출하는 람다식도 메서드 참조로 변환할 수 있다.
1
2
Supplier<MyClass> s = () -> new MyClass(); // 람다식
Supplier<MyClass> s2 = MyClass::new; // 메서드 참조
매개변수가 있는 생성자라면, 매개변수의 개수에 따라 알맞은 함수형 인터페이스를 사용하면 된다.
1
2
3
4
5
Function<Integer, MyClass> f = (i) -> new MyClass(i); // 람다식
Function<Integer, MyClass> f2 = MyClass::new; // 메서드 참조
BiFunction<Integer, String, MyClass> bf = (i, s) -> new MyClass(i, s) // 람다식
BiFunction<Integer, String, MyClass> bf = MyClass::new // 메서드 참조
배열을 생성할 때는 아래와 같이 하면 된다.
1
2
Function<Integer, int[]> f = x -> new int[x]; // 람다식
Function<Integer, int[]> f2 = int[]:new; // 메서드 참조
메서드 참조는 람다식을 마치 static변수처럼 다룰 수 있게 해준다.
출처
자바의 정석