![[인프런 워밍업 스터디 클럽] 0기 백엔드 미션 - 람다식 (Day3)](https://cdn.inflearn.com/public/files/blogs/e86e1416-3e96-480b-b000-9819ed7ed88a/332957.png)
[인프런 워밍업 스터디 클럽] 0기 백엔드 미션 - 람다식 (Day3)
과제
진도표 3일차와 연결됩니다
우리는 JdbcTemplate을 사용하는 과정에서 익명 클래스와 람다식이라는 자바 문법을 사용했습니다. 익명 클래스는 자바의 초창기부터 있던 기능이고, 람다식은 자바 8에서 등장한 기능입니다. 다음 키워드를 사용해 몇 가지 블로그 글을 찾아보세요! 아래 질문을 생각하며 공부해보면 좋습니다! 😊
[키워드]
익명 클래스 / 람다 / 함수형 프로그래밍 / @FunctionalInterface / 스트림 API / 메소드 레퍼런스
[질문]
자바의 람다식은 왜 등장했을까?
람다식과 익명 클래스는 어떤 관계가 있을까? - 람다식의 문법은 어떻게 될까?
람다
벌써 스터디 클럽 3일차가 되었다. 이번 강의에서는 DB 쿼리들에 대해서 배우고 DB를 Spring Boot 프로젝트와 연동하여 JdbcTemplate을 이용하여 실습을 해보았다. 이 과정에서 람다식이 나왔고, 오늘은 람다식에 대해 다뤄보도록 하겠다.
자바 개발자를 위한 코틀린 입문 - 17강(람다)
람다를 본격적으로 다루기 전에 강의 중에 코치님이 '자바 개발자를 위한 코틀린 입문편'에 람다를 보는 것을 추천드린다고 하셔서 학습을 해보았다.
Java에서 람다를 다루기 위한 노력
먼저 예시 코드를 살펴보자.
package me.sungbin.lecture;
public class Fruit {
private final String name;
private final int price;
public Fruit(String name, int price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public int getPrice() {
return price;
}
}
그리고 main 함수에 아래와 같이 작성한다.
List<Fruit> fruits = Arrays.asList(
new Fruit("사과", 1_000),
new Fruit("사과", 1_200),
new Fruit("사과", 1_200),
new Fruit("사과", 1_500),
new Fruit("바나나", 3_000),
new Fruit("바나나", 3_200),
new Fruit("바나나", 2_500),
new Fruit("수박", 10_000)
);
여기서 어느 손님이 와서 "사과만 보여주세요~"라고 말한다. 그러면 우리는 개발자로서 이에 해당하는 메서드를 만들어 작성할 것이다. 그런데 갑자기 조건이 붙기 시작한다. 사과뿐만 아니라, 바나나도 보여주고 각각 가격은 5000원 이상인 것들만 보여달라고 주문한다.
🤔 그래서 우리는 고민을 하다가 일일이 메서드를 만드는 것은 불필요하기에 인터페이스를 이용하기로 한다.
package me.sungbin.lecture;
public interface FruitFilter {
boolean isSelected(Fruit fruit);
}
위와 같이 인터페이스를 만들고 아래와 같이 메서드 안에 인터페이스를 적용하고 이 메서드를 호출하는 쪽에서 익명클래스로 구현해주면 된다.
package me.sungbin;
import me.sungbin.lecture.Fruit;
import me.sungbin.lecture.FruitFilter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @author : rovert
* @packageName : org.example
* @fileName : ${NAME}
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class Main {
public static void main(String[] args) {
List<Fruit> fruits = Arrays.asList(
new Fruit("사과", 1_000),
new Fruit("사과", 1_200),
new Fruit("사과", 1_200),
new Fruit("사과", 1_500),
new Fruit("바나나", 3_000),
new Fruit("바나나", 3_200),
new Fruit("바나나", 2_500),
new Fruit("수박", 10_000)
);
filterFruits(fruits, new FruitFilter() {
@Override
public boolean isSelected(Fruit fruit) {
return Arrays.asList("사과", "바나나").contains(fruit.getName()) && fruit.getPrice() >= 5_000;
}
});
}
private static List<Fruit> filterFruits(List<Fruit> fruits, FruitFilter fruitFilter) {
List<Fruit> results = new ArrayList<>();
for (Fruit fruit : fruits) {
if (fruitFilter.isSelected(fruit)) {
results.add(fruit);
}
}
return results;
}
}
🥲 익명 클래스 아쉬운 점
1. 익명클래스를 사용하는 것은 딱 봐도 복잡해 보인다.
2. 다양한 Filter가 필요할 수도 있다. ex) 과일 간의 무게 비교, n개의 과일을 한번에 비교등등...
이러한 이유로 JDK8부터 람다(이름 없는 함수) 등장하였다. 또한 FruitFilter와 같은 인터페이스와 같은 Predicate, Consumer등을 많이 만들어 두었다. 그래서 위의 코드는 아래와 같이 변경되었다.
package me.sungbin;
import me.sungbin.lecture.Fruit;
import me.sungbin.lecture.FruitFilter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
/**
* @author : rovert
* @packageName : org.example
* @fileName : ${NAME}
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class Main {
public static void main(String[] args) {
List<Fruit> fruits = Arrays.asList(
new Fruit("사과", 1_000),
new Fruit("사과", 1_200),
new Fruit("사과", 1_200),
new Fruit("사과", 1_500),
new Fruit("바나나", 3_000),
new Fruit("바나나", 3_200),
new Fruit("바나나", 2_500),
new Fruit("수박", 10_000)
);
filterFruits(fruits, fruit -> fruit.getName().equals("사과"));
}
private static List<Fruit> filterFruits(List<Fruit> fruits, Predicate<Fruit> fruitFilter) {
List<Fruit> results = new ArrayList<>();
for (Fruit fruit : fruits) {
if (fruitFilter.test(fruit)) {
results.add(fruit);
}
}
return results;
}
}
💡 람다로 변경되면서 바뀐 점
1. 호출하는 부분이
filterFruits(fruits, fruit -> fruit.getName().equals("사과"));처럼 바뀌었다.2. 그 다음에 함수는 Predicate로 통하여 리팩토링을 할 수 있다.
변수 -> 변수를 이용하는 함수 혹은 (변수1, 변수2) -> 변수1과 변수2를 이용한 함수 이런 형태가 람다다.
여기서 또 JDK8에 위의 for문과 if문을 간결하게 처리하기 위해 간결한 스트림이 등장했다. (병렬처리에도 강점)
그래서 코드가 아래와 같이 변경되었다.
package me.sungbin;
import me.sungbin.lecture.Fruit;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Fruit> fruits = Arrays.asList(
new Fruit("사과", 1_000),
new Fruit("사과", 1_200),
new Fruit("사과", 1_200),
new Fruit("사과", 1_500),
new Fruit("바나나", 3_000),
new Fruit("바나나", 3_200),
new Fruit("바나나", 2_500),
new Fruit("수박", 10_000)
);
filterFruits(fruits, fruit -> fruit.getName().equals("사과"));
}
private static List<Fruit> filterFruits(List<Fruit> fruits, Predicate<Fruit> fruitFilter) {
return fruits.stream().filter(fruitFilter).collect(Collectors.toList());
}
}
또한 람다는 아래와 같이 메서드 레퍼런스를 활용이 가능하다.
package me.sungbin;
import me.sungbin.lecture.Fruit;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
/**
* @author : rovert
* @packageName : org.example
* @fileName : ${NAME}
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class Main {
public static void main(String[] args) {
List<Fruit> fruits = Arrays.asList(
new Fruit("사과", 1_000),
new Fruit("사과", 1_200),
new Fruit("사과", 1_200),
new Fruit("사과", 1_500),
new Fruit("바나나", 3_000),
new Fruit("바나나", 3_200),
new Fruit("바나나", 2_500),
new Fruit("수박", 10_000)
);
filterFruits(fruits, Fruit::isApple);
}
private static List<Fruit> filterFruits(List<Fruit> fruits, Predicate<Fruit> fruitFilter) {
return fruits.stream().filter(fruitFilter).collect(Collectors.toList());
}
}비즈니스 로직을 도메인 메서드로 빼주고 이런 형식으로도 관리가 가능하다.
이렇게 자바에서 메서드 자체를 직접 넘겨주는 것처럼 보이지만 실제로는 인터페이스를 받기 때문이다.
이 말은 메서드는 변수에 할당하거나 파라미터로 전달할 수 없고 2급시민으로 간주한다.
위의 설명으로 잔도표에 3일차에 미션은 금방 끝나게 될 것이다. 하지만 단순 강의로 과제를 할 수는 없기에 내가 한번 더 찾아보고 학습한 내용을 공유드린다.
익명 클래스
익명 클래스가 등장한 이유는 위의 강의처럼 사용자의 요구 조건이 메서드로 처리하기엔 너무 많아지고 조건이 복잡해지면서 인터페이스 혹은 추상클래스를 이용할 때 조금 간편하게 하기 위해 등장한 것이다. 조금 더 간결히 이야기를 하면 익명 클래스는 인터페이스나 추상 클래스의 인스턴스를 간편하게 생성하기 위해 등장했습니다.
익명 클래스는 이름 없이 선언과 동시에 객체를 생성할 수 있는 클래스로, 주로 단일 사용 인스턴스에 대한 정의에 사용됩니다. 이러한 클래스는 GUI 이벤트 처리나 작은 콜백 객체 같은 곳에 유용하게 쓰입니다. 익명 클래스의 주된 목적은 코드의 간결성을 높이고, 즉석에서 필요한 구현을 제공하여 별도의 클래스 파일을 만들지 않아도 되게 하는 것입니다.
그럼 예시 코드를 보자.
package me.sungbin.blog;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : AnonymousClass
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class AnonymousClass {
public static void main(String[] args) {
Thread myThread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("익명 클래스를 사용한 스레드 실행");
}
});
myThread.start(); // Thread start
}
}
람다식(Lambda Expression)
자바가 1996년 등장안 이후 두번의 큰 변화가 있었다. 첫번째 JDK 1.5 부터 추가된 제네릭의 등장이고, 두번째 JDK 1.8 부터 추가된 람다식의 등장이다. 람다의 도입으로 인해 자바는 객체지향언어인 동시에 함수형 언어가 되었다.
람다식이란?
람다식은 간단히 말해 메서드를 하나의 식(expression) 으로 표현한 것이다. 람다식은 함수를 간략하면서도 명확한 식으로 표현할 수 있게 해준다.
메서드를 람다식으로 표현하면 메서드의 이름과 반환값이 없어지므로, 람다식을 '익명 함수(anonymous function)' 이라고도 한다.
package me.sungbin.blog;
import java.util.Arrays;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : LambdaBlogEx1
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class LambdaBlogEx1 {
public static void main(String[] args) {
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;
}
메서드 형태보다 람다식이 간결하고 이해가 쉽다.
게다가 모든 메서드는 클래스에 포함되어야 하므로 클래스도 새로 만들어야 하고, 객체도 생성해야 이 메소드를 호출할 수 있지만, 람다식은 이 과정 없이 오직 람다식 자체만으로 이 메서드의 역할을 수행할 수 있는 것이 큰 장점이다.
🙋🏻 메서드와 함수 차이
함수는 수학에서 따온 것이다. 수학의 함수와 개념이 유사하다. 그러나 OOP에서는 함수대신 객체의 행위나 동작을 의미하는 메서드라는 용어를 사용한다.
메서드는 함수와 같은 의미지만, 특정 클래스에 반드시 속해야 한다는 제약이 있기 때문에 기존의 함수와 같은 의미를 다른 용어를 선택해서 사용한 것이다. 그러나 이제 다시 람다식을 통해 메서드가 하나의 독립적인 기능을 하기 때문에 함수라는 용어를 사용하게 되었다.
람다식 작성하기
람다식은 '이름 없는 함수'답게 메서드에서 이름과 반환타입을 제거하고 매개변수 선언부와 몸통 {} 사이에 '->'를 추가한다.
AS-IS
반환타입 메서드이름(매개변수 선언){
문장들
}
TO-BE
(매개변수 선언) -> {
문장들
}
AS-IS
int max(int a, int b){
return a> b ? a: b;
}
TO-BE
(int a, int b) -> { return a > b ? a: b; }
TO-BE에서 반환 값이 있는 메서드의 경우 return문 대신 '식(expression)'으로 대신할 수 있다.
식의 연산결과가 자동적으로 반환된다.
문장이 아닌 식으로 끝에 ';'를 붙이지 않는다.
(int a, int b) -> a > b ? a: b // TO-BE
선언된 매개변수의 타입은 추론이 가능한 경우 생략할 수 있다.
람다식에 반환타입이 없는 이유도 항상 추론이 가능하기 때문이다.
(a, b) -> a > b ? a : b // TO-BE
선언된 매개변수가 하나인 경우 괄호() 를 생략할 수 있다.
단, 매개변수의 타입이 있으면 괄호()를 생략할 수 없다.
TO-BE
a -> a * a // 올바른 예
int a -> a * a // 잘못된 예괄호{} 안의 문장이 하나일 때는 괄호{}를 생략할 수 있다.
문장의 끝에 ';'을 붙이지 않아야 한다는 것에 주의한다.
AS-IS
(String name, int i) -> { System.out.println(name+"="+i); }
TO-BE
(String name, int i) -> System.out.println(name+"="+i)
함수형 인터페이스
자바에서 모든 메서드는 클래스 내에 포함되어야 하는데, 람다식은 어떤 클래스에 포함되는 것일까?
람다식은 익명 클래스의 객체와 동등하다.
(int a, int b) -> a > b ? a : b
// 위(람다식)와 아래(익명 클래스의 객체 내부 메소드)와 같다
new Object(){
int max(int a, int b){
return a > b ? a : b;
}
}
그렇다면, 람다식으로 정의된 익명 객체의 메서드를 어떻게 호출할 수 있을 것인가?
참주변수가 있어야 객체의 메서드를 호출할 수 있으니 이 익명 객체의 주소를 f 라는 참조변수에 저장해본다.
타입 f = (int a, int b) -> a > b ? a : b; // 여기서 참조변수 f의 타입은???
참조변수 f의 타입은 어떤 것이어야 할까?
참조형이니깐 클래스 또는 인터페이스가 가능하다.
그리고 람다식과 동등한 메서드가 정의되어 있는 것이어야 한다.
그래야만 참조변수로 익명 객체(람다식)의 메서드를 호출할 수 있기 때문이다.
위 내용을 바탕으로 예를 들어 max()라는 메서드가 정의된 MyFunction 인터페이스가 정의되어 있다고 가정해본다.
public interface MyFunction{
public abstract int max(int a, int b);
}
위 인터페이스를 구현한 익명 클래스의 객체는 아래와 같이 생성가능하다.
MyFunction f = new MyFunction() {
@Override
public int max(int a, int b) {
return a > b ? a: b;
}
};
int big = f.max(5, 3);
System.out.println(big);
여기서 MyFunction인터페이스에 정의된 메서드 max() 는
람다식 '(int a, int b) → a > b ? a: b' 와 일치한다.
→ 익명 객체를 담다식으로 아래와 같이 대체할 수 있다.
MyFunction f = (a, b) -> a > b ? a: b;
int big = f.max(5, 3);
System.out.println(big);
위와 같이 MyFunction 인터페이스를 구현한 익명 객체를 람다식으로 대체할 수 있는 이유는
람다식도 실제로는 익명 객체이고, MyFunction 인터페이스를 구현한 익명 객체의 메서드 max()와 람다식의 개맥변수 타입과 개수 그리고 반환값이 일치하기 때문이다.
하나의 메서드가 선언된 인터페이스를 정의해서 람다식을 다루는 것은 기존의 자바의 규칙들을 어기지 않으면서도 자연스럽다.
그렇기 때문에 인터페이스를 통해 람다식을 다루기로 결정되었으며,
람다식을 다루기 위한 인터페이스를 함수형 인터페이스(functional interface)라 부르기로 했다.
@FunctionalInterface
public interface MyFunction{
public abstract int max(int a, int b);
}단, 함수형 인터페이스에서는 오직 하나의 추상 메서드만 정의되어 있어야 한다는 제약이 있다.
그래야 람다식과 인터페이스의 메서드가 1:1로 연결될 수 있기 때문이다.
다만, static 메서드와 default 메서드의 개수에는 제약이 없다.
함수형 인터페이스로 구현한 인터페이스라면 반드시 '@FunctionalInterface' 애노테이션을 정의하도록 하자.
컴파일러가 함수형 인터페이스를 올바르게 정의하였는지 확인해주니깐
📚 바이트코드로 확인 (참고. https://dreamchaser3.tistory.com/5)
람다는 익명 내부 클래스와 다르다.
예제로 살펴보자.
FCOnline, Ready
package me.sungbin.blog;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : FCOnline
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
@FunctionalInterface
interface Ready {
void setup();
}
public class FCOnline {
public void playing(Ready ready) {
ready.setup();
System.out.println("FC Online is playing");
}
}FCOnlineExample
package me.sungbin.blog;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : FCOnlineExample
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class FCOnlineExample {
public static void main(String[] args) {
FCOnline fcOnline = new FCOnline();
fcOnline.playing(new Ready() {
@Override
public void setup() {
System.out.println("FC Online is ready??");
}
});
}
}위의 기본 예제와 람다 예제로 작성하였을 시 결과는 동일한데 어떻게 실행되고
바코드가 동일한지 궁금한지 확인해보았다.
예제에서 익명클래스인
FCOnlineExample$1새로운 클래스를 생성하여 초기화를 해주고 Ready 인터페이스를 실행하는 것과 같이 확인이 된다.컴파일 시, 익명내부클래스는 $과 같은 클래스 파일이 생긴다.
익명클래스는 INVOKESPECIAL 이란 OPCODE로 생성자를 호출하고, INVOKEVIRTUAL로 Setting을 호출한다.
익명클래스 & Function Type
자바에서는 왜 람다를 내부적으로 익명클래스로 컴파일하지 않을까?
Java8 이전 버전에서 람다를 쓰기 위한 retrolambda 같은 라이브러리나, kotlin 같은 언어에서는 컴파일 시점에 람다를 단순히 익명클래스로 치환이 된다.
다만, 익명 클래스로 사용할 경우 아래와 같은 문제가 발생할 수 있다.
항상 새로운 인스턴스로 할당한다.
람다식마다 클래스가 하나씩 생기게 된다.
람다 예제 바이트 코드
람다예제의 바이트코드에서는 기본예제의 바이트코드와 다른점이 있었다.
새로운 메서드를 static으로 생성하고 있는 부분을 볼 수 있다.
중간즈음 INVOKEDYNAMIC setup() ... 이라는 구문을 볼 수 있는데 이 부분이 바로
INVOKEDYNAMIC CALL → INDY 이다.
INDY가 호출되게되면 bootstrap 영역의
lambdafactory.metafactory()를 수행하게 된다.lambdafactory.metafactory(): java runtime library의 표준화 method어떤 방법으로 객체를 생성할지 dynamically 를 결정한다.
클래스를 새로 생성, 재사용, 프록시, 래퍼클래스 등등 성능향상을 위한 최적화된 방법을 사용하게 된다.
java.lang.invoke.CallSite객체를 return 한다.LambdaMetaFactory ~ 이렇게 되어 있는 곳의 끝에 CallSite 객체를 리턴하게 된다.
해당 lambda의 lambda factory, MethodHandle을 멤버변수로 가지게 된다.
람다가 변환되는 함수 인터페이스의 인터페이스를 반환한다.
한번만 생성되고 재호출시 재사용이 가능하다.
📚 더 알아보기
INVOKEDYNAMIC으로 구현되어 있는 이유는 여러가지가 있지만 자바의 버전이 올라갈 때 인보크 다이나믹으로 구현한 부분은 하위호환성을 유지하면서 개선할 여지를 가지고 있다.
중간 정리
함수형 인터페이스 (Functional Interface)
추상 메소드를 딱 하나만 가지고 있는 인터페이스
SAM(Single Abstract Method) 인터페이스
@FunctionalInterface 에노테이션을 가지고 있는 인터페이스
람다 표현식 (Lambda Expressions)
함수형 인터페이스의 인스턴스를 만드는 방법으로 쓰일 수 있다.
코드를 줄일 수 있다.
메소드 매개변수, 리턴파입, 변수로 만들어 사용할 수 있다.
자바에서 함수형 프로그래밍
함수를 First Class Object로 사용할 수 있다.
순수 함수 (Pure Function)
사이드 이팩트 만들 수 없다. (함수 밖에 있는 값을 변경하지 못한다.)
상태가 없다. (함수 밖에 정의되어 있는)
고차 함수 (High-Order Function)
함수가 함수를 매개변수로 받을 수 있고 함수를 리턴할 수 있다.
추상 메서드 하나만 있으면 함수형 인터페이스다.
MyFunction.java Interface는 추상메서드 하나만 가지고 있기 때문에 함수형 인터페이스
@FunctionalInterface
public interface MyFunction {
int max(int a, int b);
}-> @FunctionalInterface 애노테이션을 정의하고 나서 추가적인 추상 메서드를 입력하면, 컴파일 시 에러가 발생된다. (why? 함수형 인터페이스가 아니게 됨으로)
인터페이스에 static, default 메소드를 선언할 수 있다.
아래와 같이 다른 형태(static, default) 메소드가 있더라도, 추상 메소드 하나만 있다면 FunctionalInterface 이다.
@FunctionalInterface
public interface MyFunction {
int max(int a, int b);
static void printNumber() {
System.out.println(1);
}
default void printDefaultNumber() {
System.out.println(0);
}
}
위에서 정의한 함수형 인터페이스를 이용해보자.
public class App {
public static void main(String[] args) {
MyFunction myFunction = new MyFunction() {
@Override
public void printAnyThing() {
System.out.println("anything");
}
};
}
}위의 코드는 익명내부클래스를 정의하는 방식이다.
-> 람다로 변경
public class App {
public static void main(String[] args) {
MyFunction myFunction = () -> System.out.println("anything");
}
}
public class App {
public static void main(String[] args) {
MyFunction myFunction = () -> {
System.out.println("anything");
System.out.println("Lambda");
};
myFunction.printAnyThing();
}
}함수형 인터페이스를 인라인으로 구현한 오브젝트로 볼 수 있다.
위 예시와 같이 구현한 자체를 Return 하거나, 메소드의 파라미터로 전달할 수도 있다.
@FunctionalInterface
public interface MyFunction {
void printAnyThing(String name);
static void printNumber() {
System.out.println(1);
}
default void printDefaultNumber() {
System.out.println(0);
}
}package me.sungbin.blog;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
MyFunction myFunction = name -> System.out.println(name);
myFunction.printAnyThing("양성빈");
myFunction.printAnyThing("인프런");
}
}
같은 값을 넣었을 때 같은 값이 나오는 것. pure한 함수
그렇지 않으면, 함수형 프로그래밍이 X
그렇지 않은 경우가 어떻게? → 함수 밖에 있는 값을 참조해서 사용하는 경우 (상태값에 의존한다는 의미) → 외부에 있는 값을 변경하려는 경우
package me.sungbin.blog;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
MyFunction myFunction = new MyFunction() {
int baseNumber = 100;
@Override
public void printAnyThing(String name) {
baseNumber++;
System.out.println(baseNumber + name);
}
};
}
}아래와 같은 경우 참조는 할 수 있지만, 변경할 수 없다.
final 이라 가정하고 사용될 수 있는 경우이다.
package me.sungbin.blog;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
int baseNumber = 100;
MyFunction myFunction = name -> System.out.println(baseNumber + name);
}
}
이러한 경우들은 함수형 프로그래밍과 거리가 멀다.
Java에서 기본으로 제공하는 함수형 인터페이스
ava.lang.function 패키지
자바에서 미리 정의해둔 자주 사용할만한 함수 인터페이스
Function<T, R>
BiFunction<T, U, R>
Consumer<T>
Supplier<T>
Predicate<T>
UnaryOperator<T>
BinaryOperator<T>
....
Function<T, R>
값을 하나 받아서 리턴하는 일반적인 함수
R apply<T>Plus.java → implements Function<Integer, Integer>
Integer값을 받아서 Integer 값으로 반환하고자 함.
package me.sungbin.blog;
import java.util.function.Function;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : Plus
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class Plus implements Function<Integer, Integer> {
@Override
public Integer apply(Integer integer) {
return integer + 100;
}
}
package me.sungbin.blog;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
int baseNumber = 100;
MyFunction myFunction = name -> System.out.println(baseNumber + name);
Plus plus = new Plus();
System.out.println(plus.apply(1));
}
}
위와 같은 동작을 하는 함수를 Plus라는 별도 클래스 없이도 사용할 수 있다.
Function<Integer, Integer> 함수형 인터페이스를 바로 구현
package me.sungbin.blog;
import java.util.function.Function;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
int baseNumber = 100;
MyFunction myFunction = name -> System.out.println(baseNumber + name);
Function<Integer, Integer> plus10 = (number) -> number + 100;
System.out.println(plus10.apply(1));
}
}
함수의 조합도 가능하다.
compose
입력값을 가지고 먼저 뒤에 오는 함수를 적용한다.
그 결과값을 다시 입력값으로 사용하는 것이다.
package me.sungbin.blog;
import java.util.function.Function;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
Function<Integer, Integer> plus10 = (number) -> number + 10;
Function<Integer, Integer> multiply2 = (number) -> number * 2;
System.out.println(plus10.apply(1));
System.out.println(multiply2.apply(1));
Function<Integer, Integer> multiply2AndPlus10 = plus10.compose(multiply2);
System.out.println(multiply2AndPlus10.apply(2));
}
}andThen
compose와 반대로 먼저 적용하고 뒤에 오는 함수를 적용한다.
package me.sungbin.blog;
import java.util.function.Function;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
Function<Integer, Integer> plus10 = (number) -> number + 10;
Function<Integer, Integer> multiply2 = (number) -> number * 2;
System.out.println(plus10.apply(1));
System.out.println(multiply2.apply(1));
Function<Integer, Integer> plus10AndMultiply2 = plus10.andThen(multiply2);
System.out.println(plus10AndMultiply2.apply(2));
}
}
BiFunction<T, U, R>
Function<T, R> 과 유사하지만, 입력값을 2개를 받는 것이다.
(T, U) → R
R apply(T t, U u)
Consumer<T>
리턴이 없다. | 함수 조합용 메소드 : andThen
void Accept(T t)Consumer<T> 함수형 인터페이스 사용 예시
package me.sungbin.blog;
import java.util.function.Consumer;
import java.util.function.Function;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
Consumer<Integer> printT = System.out::println;
printT.accept(100);
}
}
Supplier<T>
T 타입의 값을 제공해주는 함수형 인터페이스
T get()
Supplier<T> 사용 예시
package me.sungbin.blog;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
Supplier<Integer> get100 = () -> 100;
System.out.println(get100.get());
}
}
Predicate<T>
T 타입의 값을 받아서 boolean 을 반환하는 함수 인터페이스
boolean test(T t)
함수 조합용 메소드
And, Or, Negate
Predicate<T> 사용 예시
package me.sungbin.blog;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
Predicate<String> startsWithYang = (str) -> str.startsWith("yang");
Predicate<Integer> isEven = (i) -> i % 2 == 0;
}
}
UnaryOperator<T>
Function<T, R>의 특수한 형태
입력값 하나를 받아서 동일한 타입을 리턴하는 함수 인터페이스
입력/리턴 값이 같으므로 이전의 Function<T, R> 을 아래와 같이 변경할 수 있다.
package me.sungbin.blog;
import java.util.function.*;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
UnaryOperator<Integer> plus10 = (number) -> number + 10;
UnaryOperator<Integer> multiply2 = (number) -> number * 2;
}
}
BinaryOperator<T>
BiFunction<T, U, R> 의 특수한 형태
동일한 타입의 입력값 2개를 받아서 리턴하는 함수 인터페이스
3개의 타입이 다 같을 것이라는 가정으로 작성됨.
📚 자바 api에서 제공해주는 함수형 인터페이스의 별명
Function
별명 : 트랜스포머(변신로봇)
이유 : 값을 변환하기 때문에!
Consumer
별명 : Spartan (스파르탄!)
이유 : 모든 것을 빼앗고 아무것도 내주지 마라 !
Predicate
별명 : 판사
이유 : 참 거짓으로 판단하기 때문
Suppliers
별명 : 게으른 공급자.
이유 : 입력값이 존재하지 않는데, 내가 원하는 것을 미리 준비하기 때문
람다
(인자 리스트) → {바디}
인자 리스트
인자가 없을 때 : ()
인자가 한개 일 때 : (one) 또는 one
인자가 여러개 일 때 : (one, two)
인자 타입은 생략 가능
→ 컴파일러가 추론(infer)하지만 명시할 수도 있다. → (Integer one, Integer two)
바디
화살표 오른쪽에 함수 본문을 정의
여러 줄인 경우 { } 을 사용하여 묶는다.
한 줄인 경우 생략 가능, return 또한 생략 가능하다.
변수 캡쳐 (Variable Capture)
로컬 변수 캡쳐
final이거나 effective final인 경우에만 참조할 수 있다.
변수를 변경되도록 수정해보면 이것은 effective final 인지 아닌지 확인가능하다.
변경이 되면 effective final 이 아니게 되며, 람다에서 사용할 수 없게 된다.
그렇지 않을 경우 concurrency 문제가 생길 수 있어서 컴파일이 불가능하다.
effective final
이것 역시 자바 8 부터 지원하는 기능으로 "사실상" final인 변수.
final 키워드 사용하지 않은 변수를 익명 클래스 구현체 또는 람다에서 참조할 수 있다.
익명 클래스 구현체와 달리 "쉐도윙" 하지 않는다.
익명 클래스는 새로 스콥을 만들지만, 람다는 람다를 감싸고 있는 스콥과 같다.
변수 캡쳐 케이스 예.
→ run() 메소드의 int baseNumber 는 IntConsumer 람다에서 참조되고 있다.
package me.sungbin.blog;
import java.util.function.*;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : BlogExample
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class BlogExample {
public static void main(String[] args) {
/**
* 순수함수프로그래밍을 할려면 외부에 있는 값을 변경하거나 참조하면 안된다. 함수 내부 및 파라미터만 가지고 써야한다.
*/
// int baseNumber = 10;
// RunSomething runSomething = number -> number + baseNumber;
// System.out.println(runSomething.doIt(2));
//
// UnaryOperator<Integer> plus10 = (i) -> i + 10;
// UnaryOperator<Integer> multiply2 = (i) -> i * 2;
// Function<Integer, Integer> multiply2AndPlus10 = plus10.compose(multiply2);
//
// Consumer<Integer> printT = System.out::println;
// Supplier<Integer> get10 = () -> 10;
//
// Predicate<String> startsWithSungbin = (str) -> str.startsWith("sungbin");
//
// System.out.println(plus10.apply(1));
// System.out.println(multiply2.apply(1));
// System.out.println(multiply2AndPlus10.apply(2));
// System.out.println(plus10.andThen(multiply2).apply(2));
// printT.accept(10);
// System.out.println(get10.get());
// System.out.println(startsWithSungbin.test("sungbin"));
UnaryOperator<Integer> plus10 = (i) -> i + 10;
UnaryOperator<Integer> multiply2 = (i) -> i * 2;
System.out.println(plus10.andThen(multiply2).apply(2));
Supplier<Integer> get10 = () -> 10;
BinaryOperator<Integer> sum = Integer::sum;
BlogExample example = new BlogExample();
example.run();
}
private void run() {
int baseNumber = 10;
// 내부 클래스 :: 쉐도잉 가능
class LocalClass {
void printBaseNumber() {
int baseNumber = 11;
System.out.println(baseNumber);
}
}
// 익명 클래스 :: 쉐도잉 가능
Consumer<Integer> integerConsumer = new Consumer<Integer>() {
@Override
public void accept(Integer baseNumber) {
System.out.println(baseNumber);
}
};
// 람다
IntConsumer printInt = (i) -> {
System.out.println(i + baseNumber);
};
printInt.accept(10);
LocalClass localClass = new LocalClass();
localClass.printBaseNumber();
integerConsumer.accept(11);
}
}
로컬 클래스와 익명 클래스 <> 람다와 다른 점
→ 쉐도윙 (가려지는 것, 덮어지는 것)
로컬 클래스와 익명 클래스는 메소드 내에서 새로운 Scope 이다.
→ 쉐도잉 발생
-> 쉐도잉 발생
int baseNumber = 10;
// 1. 로컬 클래스
class LocalClass{
void PrintBaseNumber(){
int baseNumber = 11;
// baseNumber 값은 11이 찍힐 것이다. (scope)
// run 메소드에서 선언한 baseNumber에 대해 쉐도잉이 발생
System.out.println(baseNumber);
}
}
// 2. 익명 클래스
Consumer<Integer> integerConsumer = new Consumer<Integer>() {
@Override
public void accept(Integer baseNumber) {
// 파라미터로 전달받은 baseNumber 가 찍힐 것이다.
// run 메소드에서 선언한 baseNumber에 대해 쉐도잉이 발생
System.out.println(baseNumber);
}
};
람다는 람다를 감싸고 있는 메소드와 같은 Scope이다. → 같은 이름의 변수를 선언할 수 없다.
→ 람다에 들어있는 변수와 람다가 사용되고 있는 클래스의 변수들은 같은 Scope이다.
int baseNumber = 10;
// 3. 람다
IntConsumer printInt = (baseNumber) -> {
System.out.println(baseNumber);
};위와 같이 선언하게 되는경우 에러가 발생하게 된다.
→ Variable 'baseNumber' is already defined in the scope
Variable Capture의 자세한 설명 추가
람다식의 실행 코드 블록 내에서 클래스의 멤버 필드와 멤버 메소드, 그리고 지역 변수를 사용할 수 있다.
클래스의 멤버 필드와 멤버 메소드는 특별한 제약없이 사용 가능하지만, 지역변수를 사용함에 있어 제약이 존재한다.
이 내용을 이해하기 위해서는 jvm 메모리에 대해 알아야 한다.
잠시 람다식이 아닌 다른 얘기를 해보자.
멤버 메소드 내부에서 클래스의 객체를 생성해서 사용할 경우 다음과 같은 문제가 있다.
익명 구현 객체를 푸함해서 객체를 생성할 경우 new 라는 키워드를 사용한다.
new라는 키워드를 사용한다는 것은 동적 메모리 할당 영역(이하 heap)에 객체를 생성한다는 의미이다.
이렇게 생성된 객체는 자신을 감싸고 있는 멤버 메소드의 실행이 끝난 이후에도 heap영역에 존재하므로 사용할 수 있지만, 이 멤버 메소드에 정의된 매개변수나 지역 변수는 런타임 스택 영역(이하 stack)에 할당되어 메소드 실행이 끝나면 해당 영역에서 사라져 더 이상 사용할 수 없게 된다.
그렇기 때문에 멤버 메소드 내부에서 생성된 객체가 자신을 감싸고 있는 메소드의 매개변수나 지역변수를 사용하려 할 때 문제가 생길 수 있다.
클래스의 멤버 메소드의 매개변수와 이 메소드 실행 블록 내부의 지역변수는 JVM의 STACK에 생성되고 실행이 끝나면 STACK에서 사라진다.
new 연산자를 사용해서 생성한 객체는 JVM의 HEAP영역에 객체가 생성되고 GC(Garbage Collector)에 의해 관리되며, 더 이상 사용하지 않는 객체에 대해 필요한 경우 메모리에서 제거한다.
heap에 생성된 객체가 stack의 변수를 사용하려고 하는데, 사용하는 시점에 stack에 더 이상 해당 변수가 존재하지 않을 수 있다는 것이다.
왜냐하면 stack은 메소드 실행이 끝나면 매개변수나 지역변수에 대해 제거하기 때문이다.
그래서 더 이상 존재하지 않는 변수를 사용하려 할 수 있기 떄문에 오류가 발생한다.
→ 자바는 이 문제를 Variable Capture 라고 하는 값 복사를 사용해서 해결한다.
즉, 컴파일 시점에 멤버 메소드의 매개변수나 지역변수를 멤버 메소드 내부에서 생성한 객체가 사용할 경우 객체 내부로 값을 복사해서 사용한다.
하지 모든 값을 복사해서 사용할 수 있는 것은 아니다.
여기에도 제약이 존재하는데 final 키워드로 작성되었거나 final 성격을 가져야 한다.
final 키워드는 알겠는데 final 성격을 가져야한다는 것은 왜그럴까?
final 성격을 가진다는 것은 final 키워드로 선언된 것은 아니지만 값이 한번만 할당되어 final 처럼 쓰이는 것을 뜻한다.
복잡한 내용과 예제가 존재하지만, 쉽게 생각한다면 익명 구현 객체를 사용할 때와 람다식을 사용했을 때 다음과 같은 차이점이 있다는 것만이라도 기억해보자.
람다식은 익명 구현 객체 처럼 별도의 객체를 생성하거나 컴파일 결과 별도의 클래스를 생성하지 않는 다는 것이다.
람다식 내부에서 사용하는 변수는 Variable Capture가 발생하며, 이 값은 final이거나 final처럼 사용해야 한다는 것이다.
익명 구현 객체에 대해서는 new를 사용해서 객체도 생성된 것으로 보이고 별도 클래스 파일이 생긴 것을 확인할 수 있을 것이다.
람다식이 쓰인 부분에서는 INVOKEDYNAMIC 이라는 OPCODE를 사용했는데, JAVA8 부터 생긴 것으로 interface의 default method와 lambda 식에서 사용된다고 한다.
메소드 레퍼런스
람다가 하는 일이 기준 메소드 또는 생성자를 호출하는 것이라면, 메소드 레퍼런스를 사용해서 매우 간결하게 표현할 수 있다.
메소드 참조하는 방법
스태틱 메소드 참조 → 타입::스태틱 메소드
특정 객체의 인스턴스 메소드 참조 → 객체 래퍼런스::인스턴스 메소드
임의 객체의 인스턴스 메소드 참조 → 타입::인스턴스 메소드
생성자 참조 → 타입::new
메소드 또는 생성자의 매개변수로 람다의 입력값을 받는다.
리턴값 또는 생성한 객체는 람다의 리턴 값이다.
package me.sungbin.blog;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : Eating
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class Eating {
private String food;
public Eating() {
}
public Eating(String food) {
this.food = food;
}
public String eat(String food) {
return "eating " + food;
}
public static String keepEat(String food) {
return "keep eating " + food;
}
}
Function<T, R> 을 이용해 구현 가능하지만, 동일한 작업을 하는 Greeting 객체의 메소드를 활용하여 아래와 같이 작업해볼 수 있다.
메소드 레퍼런스 -> Eating::keepEat
package me.sungbin.blog;
import java.util.function.UnaryOperator;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
UnaryOperator<String> keepEatFunction = (s) -> "hi " + s;
UnaryOperator<String> keepEatingObject = Eating::keepEat;
System.out.println(keepEatingObject.apply("햄버거"));
}
}인스턴스 메서드 사용
package me.sungbin.blog;
import java.util.function.UnaryOperator;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
Eating eating = new Eating();
UnaryOperator<String> printEat = eating::eat;
System.out.println(printEat.apply("햄버거"));
}
}
생성자 사용
Supplier를 이용한 것과 Function을 이용한 생성자 호출은 엄연히 다르다.
Supplier는 인자가 없고 Function은 인자가 있다.
사용하는 부분인 메소드 레퍼런스만 보면 "Eating::new" 와 동일하지만 다르다는 점!
package me.sungbin.blog;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
// 입력값은 없는데 반환값은 있는 함수형 인터페이스 > Supplier
Supplier<Eating> newEating = Eating::new;
Eating eating = newEating.get();
}
}package me.sungbin.blog;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
// 입력값 T 를 받아 R 반환 함수형 인터페이스 > Function
Function<String, Eating> hamburgerEating = Eating::new;
Eating hamburger = hamburgerEating.apply("햄버거");
}
}
임의의 객체를 참조하는 메소드 레퍼런스
package me.sungbin.blog;
import java.util.Arrays;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
String[] names = {"A", "B", "C", "D"};
Arrays.sort(names, String::compareToIgnoreCase);
System.out.println(Arrays.toString(names));
}
}람다식의 타입과 형변환 정리!
함수형 인터페이스로 람다식을 참조할 수 있는 것일 뿐이지 람다식의 타입이 함수형 인터페이스의 타입과 일치하는 것은 아니다.
람다식은 익명 객체이고 익명 객체는 타입이 없다.
정확히는 타입은 있지만 컴파일러가 임의로 이름을 정하기 때문에 알 수 없는 것이다.
그래대입 연산자의 양변의 타입을 일치시키기 위해 형변환이 필요하다.
MyFunction f = (MyFunction)(() -> {...});람다식은 MyFunction 인터페이스를 직접 구현하지 않았지만, 이 인터페이스를 구현한 클래스의 객체와 완전히 동일하기 때문에 위와 같은 형변환을 허용한다. 그리고 이 형변환은 생략가능하다.
람다식은 이름이 없을 뿐 분명히 객체인데도, Object 타입으로 형변환할 수 없다.
람다식은 오직 함수형 인터페이스로만 형변환이 가능하다.
Object obj = (Object)( () -> { ... }); // ERROR. 함수형 인터페이스로만 가능하다.
굳이 변경하고자 한다면, 함수형 인터페이스로 변환하고 난 후 가능하다.
다음 예제를 통해 컴파일러가 람다식의 타입을 어떤 형식으로 만들어내는지 알아보자.
package me.sungbin.blog;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : MyFunction02
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
@FunctionalInterface
public interface MyFunction02 {
void myMethod();
}package me.sungbin.blog;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
MyFunction02 f = () -> {};
Object obj = (MyFunction02) (() -> {});
String str = ((Object) (MyFunction02) (() -> {})).toString();
System.out.println(f);
System.out.println(obj);
System.out.println(str);
System.out.println((MyFunction02) (() -> {}));
System.out.println(((Object) (MyFunction02) (() -> {})).toString());
}
}
일반적인 익명 객체라면, 객체의 타입이 외부클래스이름$번호 와 같은 형식으로 타입이 결정되었을텐데, 람다식의 타입은 외부클래스이름$Lambda$번호 와 같은 형식으로 되어 있는 것을 확인할 수 있다.
INDY 상세한 정리!
INVOKEDYNAMIC 의 내부 동작 분석
Java SE7 부터 등장한 새로운 바이트코드 셋이다.
기존에는 invoke 시리즈는 4가지만 존재하였다. (invoke + virtual/static/interface/special)
invokevirtual : instance 메소드를 디스패치 하기 위한 명령어
invokestatic : static 메소드를 디스패치 하기 위한 명령어
invokeinterface : 인터페이스를 통해서 method를 디스패치 하기 위한 명령어
invokespecial : 생성자, 수퍼클래스, private method등 invoke-virtual이 아닌 메소드들을 디스패치 하기 위한 명령어
저 명령어들을 보면 어느 한 메소드를 부르기 위해서는 아래와 같은 4가지 메소드 정보가
java에 명확하게 선언되어 있어야 한다.
메소드의 이름
메소드 시그니처 + return type
메소드가 정의되어 있는 클래스
메소드를 실행할 수 있는 바이트 코드.
즉, 메소드를 부르기 위해서는 위와 같은 정보들이 자바 lang을 통해 고정되어 있고 이미 모든 것이 구현되어 있고 컴파일까지 완벽하게 되어 있어서 JVM에서 바이트코드를 읽기만 하면 된다.
Java SE7 에서는 언어의 로직들이 컴파일러가 번역해준 메소드 실행 로직이 아닌, 런타임에서 메소드를 실행할 CALL TARGET을 정할 수 있도록 INVOKEDYNAMIC이라는 바이트코드를 추가하였다.
Java 코드로 작성된 Lambda랑 INVOKEDYNAMIC 과 무슨 상관일까?
invokedynamic의 예시를 보면, 마치 다양한 언어를 JVM 위에서 돌릴 수 있도록 추가된 바이트코드처럼 보인다.
람다는 Java로 쓰여져있고, 람다를 통해 생성된 바이트코드를 보면 모두 컴파일 시점에 자바 메소드로 재분해(desugar) 확인할 수 있다.
그렇다면 람다가 굳이 invokedynamic을 사용하도록 컴파일되는 이유는 무엇일까?
특정 translation strategy (람다를 → 가용가능한 자바 로직으로 변환하는 과정 및 전략) 에는 두가지 고려사항이 존재한다.
미래의 최적화를 위해서 특정 전략으로 고정하지 않는 것. (즉, 최대한 바이트코드로 고정되어 컴파일 되지 않게 하는 것)
특정 translation strategy (실제 자바 실행 로직으로 변환하는 과정 및 전략)을 런타임에서 결정할 수 있다. 따라서, 전략이 미래에 변해서 JVM 스팩이 업데이트 되었다고 하더라도 소스코드 수정이나, 재컴파일 없이 그대로 실행 가능하다.
만약 람다가 컴파일 타임에서 완벽하게 변환되었다고 한다면, 나중에 수정사항이 있을 경우 프로젝트를 모두 재컴파일 해야 하는 일이 발생한다.
클래스 파일 표현에 안정성을 가지는 방법
람다는 두가지의 이점을 가지기 위해,
'람다라는 표현 () → {}' 을 '실제 자바 메소드 실행 로직' (바이트코드로 나온 실행 메소드)로 컴파일 타임이 아닌 INVOKEDYNAMIC 을 통해서 런타임에서 로직을 연결하고 실행한다.
이를통해서, 실제 람다 표현을 실행하는 로직을 결정하는 전략을 런타임에서 LAZY 하게 셜정할 수 있다는 것이 장점이라고 생각된다.
Invokedynamic + lambda 실행
public class SimpleLambda{
public static void main(String[] args){
Runnable lambda = invokedynamic(
bootstrap = LambdaMetafactory,
staticargs = [Runnable, lambda$0],
dynargs=[]);
lambda.run();
}
private static void lambda$0(){
System.out.println(1);
}
}
invokedynamic()
Bootstrap Method (or BSM)
부트스트랩 메소드는 invokedynamic() + bootstrap method()를 통해 들어온 정보를 기반으로, 호출 대상을 찾아서 연결하고 CallSite 객체를 반환한다.
CallSite가 반환되기 전을 unlaced 상태(실제 로직이 연결되지 않은 상태)라고 하며, invokedynamic() 콜이 제대로 불려 실제로 linkage가 일어나면 **laced(연결된) 상태**라고 불린다.
VM이 bootstrap method를 부를 때에, CallSite를 lazy 하게 반환하며, 반환 후에는 CallSite를 통해 람다와 실제 함수 구현 부분이 연결된다.
연결을 한번 한 뒤에는 계속 연결상태가 되기 때문에, 따로 링킹을 시도하지 않는다.
Lambda는 LambdaMetafactory.metafactory 라는 부트스트랩 메소드를 부른다.
1-1). CallSite & MethodHandle
이 CallSite 객체에는 실제 메소드를 실행시킬 메소드 (아까 바이트코드에서 봤던 private static method) 포함되어 있다.
📚 참조 https://www.slideshare.net/DanHeidinga/invokedynamic-evolution-of-a-language-feature
CallSite 가 멤버변수로 가지고 있는 실제 로직을 가리키고 있는 메소드는 MethodHandle로 표현된다.
아래의 코드 예제를 보면, 일반적으로 Reflection API를 통해 메소드를 Method 객체를 얻은것과 비슷해 보이지만 훨씬 더 VM 레벨에서 작동하는 메소드이다.
public MethodHandle getToStringMH() {
MethodHandle mh = null;
// 메소드 타입 부터 첫번째 파라미터는 Return type, 두번째부터는 메소드 파라미터들..
MethodType mt = MethodType.methodType(String.class);
// 메소드 handles의 lookup() = "lookup context"
MethodHandles.Lookup lk = MethodHandles.lookup();
try {
// mh를 통해 toString메소드를 찾음.
mh = lk.findVirtual(getClass(), "toString", mt);
} catch (NoSuchMethodException | IllegalAccessException mhx) {
throw (AssertionError)new AssertionError().initCause(mhx);
}
return mh;
}
2) staticargs, dynargs
staticargs : 바이트 코드로 변환된 람다 실제 메소드 정보
dynargs : 람다 스코프 외 외부변수 참조 시, dynargs에 포함됨.
invokedynamic 이 부트스트랩 메소드를 여러 인자 요소들(메소드 정보, 메소드 구현체 정보, 타입 정보 등..)과 함께 부른다.
BootstrapMethod는 CallSite를 반환한다.
CallSite는 target method의 정보를 가지고 있는 method handler를 멤버 변수로 가지고 있고, 이 method handler를 통해 실제 동작하는 메소드와 연결된다.
즉, lambda로 인해 컴파일 시점에 추가된 static/instance 함수 (예 : private static void lambda$0)를 LambdaMetaFactory가 MethodHandler를 통해 관리해주고 있는 형태로 볼 수 있다.
Stream 소개
Stream
sequence of elements supporting sequential and parallel aggregate operations
데이터를 담고 있는 저장소(컬렉션)이 아니다.
Functional in nature, 스트림이 처리하는 데이터 소스를 변경하지 않는다.
→ Functional 하다.
→ 결과가 또다른 stream이 되는 것이지, 전달받은 데이터 자체가 변경되는 것이 아니다.
스트림으로 처리하는 데이터는 오직 한번만 처리한다.
→ 컨베이어 밸트에 항목이 한번 지나가는 것이라고 보면된다. (한번 지나면 끝)
무제한일 수도 있다. (Short Circuit 메소드를 사용해서 제한할 수 있다.)
중개 오퍼레이션은 근본적으로 lazy 하다.
→ stream에 사용하는 것은 2개로 나눌 수 있다. (중개, 종료)
→ 중개 오퍼레이션은 lazy.. ???
→ 중개형 오퍼레이션은 종료 오퍼레이션이 오기 전까지 실행되지 않는다.
package me.sungbin.blog;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("손흥민");
names.add("박지성");
names.add("이강인");
names.add("김민재");
names.add("조규성");
names.stream().map(x -> {
System.out.println(x);
return x.toUpperCase(Locale.ROOT);
});
System.out.println("==========");
names.forEach(System.out::println);
}
}.map() 바디에 선언한 System.out.println 은 찍히지 않는 것을 볼 수 있다.
종료형 오퍼레이션이 반드시 한번 와야 하며, 종료형 오퍼레이션이 오지 않으면 중계형 오퍼레이터는 의미가 없다. (실행x)
손쉽게 병렬 처리 할 수 있다.
병렬처리를 하는 것이 모두 빠른 것이 아니다. 더 느릴 수 있다.
Thread를 만들어서 Thread별로 병렬로 처리하고 수집하는 일련의 과정이 발생된다.
데이터가 정말 방대하게 큰 경우 유용하게 사용될 수 있으나, 그게 아니라면 stream 권장
Stream Pipline
0 또는 다수의 중개 오퍼레이션 (intermediate operation)과 한개의 종료 오퍼레이션(terminal operation)으로 구성한다.
스트림의 데이터 소스는 오직 터미널 오퍼레이션을 실행할 때만 처리한다.
중개 오퍼레이션
Stream을 리턴한다.
Stateless / Stateful 오퍼레이션으로 더 상세하게 구분할 수도 있다.
대부분 Stateless 지만 distinct나 sorted 처럼 이전 소스 데이터를 참조해야 하는 오퍼레이션은 Stateful 오퍼레이션이다.
filter, map, limit, skip, sorted ...
종료 오퍼레이션
Stream을 리턴하지 않는다.
collect, allMatch, count, forEach, min, max
Stream API
걸러내기
Filter(Predicate)
예) 이름이 3글자 이상인 데이터만 새로운 스트림으로
변경하기
Map(Function) 또는 FlatMap(Function)
예) 각각의 Post인스턴스에서 String Title만 새로운 스트림으로
예) List<STream<String>> 을 String의 스트림으로
생성하기
generate(Supplier) 또는 Iterate(T seed, UnaryOperator)
예) 10부터 1씩 증가하는 무제한 숫자 스트림
예) 랜덤 int 무제한 스트림
제한하기
limit(long) 또는 skip(long)
예) 최대 5개의 요소가 담긴 스트림을 리턴한다.
예) 앞에서 3개를 뺀 나머지 스트림을 리턴한다.
package me.sungbin.blog;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
/**
* @author : rovert
* @packageName : me.sungbin.blog
* @fileName : App
* @date : 2/21/24
* @description :
* ===========================================================
* DATE AUTHOR NOTE
* -----------------------------------------------------------
* 2/21/24 rovert 최초 생성
*/
public class App {
public static void main(String[] args) {
List<Blog> developBlogs = new ArrayList<>();
developBlogs.add(new Blog(1L, "자바", "스트림 API", true));
developBlogs.add(new Blog(1L, "mysql", "롤백", true));
developBlogs.add(new Blog(1L, "spring boot", "DI", false));
developBlogs.add(new Blog(1L, "spring data jpa", "트랜잭션", false));
developBlogs.add(new Blog(1L, "spring security", "cors", false));
System.out.println("spring 으로 시작하는 블로그");
System.out.println("공개 블로그");
System.out.println("블로그 이름만 만들어서 스트림 만들기");
}
}
1. spring으로 시작하는 수업 만들기
System.out.println("spring 으로 시작하는 수업");
List<Blog> blogsByTitleIsSpringStartWith =
developBlogs.stream()
.filter(x -> x.getTitle().startsWith("spring"))
.collect(Collectors.toList());
blogsByTitleIsSpringStartWith.forEach(x -> System.out.println(" > " + x.getTitle()));
2. secret되지 않는 블로그
System.out.println("공개 블로그");
List<Blog> notSecretBlog =
developBlogs.stream()
.filter(x -> !x.isSecret())
.collect(Collectors.toList());
notSecretBlog.forEach(x -> System.out.println(" > " + x.getTitle()));
3. 블로그 이름만 모아서 스트림 만들기
List<String> blogsByTitle =
developBlogs.stream()
.map(Blog::getTitle)
.collect(Collectors.toList());
blogsByTitle.forEach(x -> System.out.println(" > " + x));연습 https://www.inflearn.com/course/the-java-java8
public class StreamApp {
public static void main(String[] args) {
List<OnlineClass> springClasses = new ArrayList<>();
springClasses.add(new OnlineClass(1, "spring boot", true));
springClasses.add(new OnlineClass(2, "spring data jpa", true));
springClasses.add(new OnlineClass(3, "spring mvc", false));
springClasses.add(new OnlineClass(4, "spring core", false));
springClasses.add(new OnlineClass(5, "rest api development", false));
List<OnlineClass> javaClasses = new ArrayList<>();
javaClasses.add(new OnlineClass(6, "The Java, Test", true));
javaClasses.add(new OnlineClass(7, "The Java, Code manipulation", true));
javaClasses.add(new OnlineClass(8, "The Java, 8 to 11", false));
List<List<OnlineClass>> ssonEvents = new ArrayList<>();
ssonEvents.add(springClasses);
ssonEvents.add(javaClasses);
System.out.println("두 수업 목록에 들어있는 모든 수업 아이디 출력");
// todo
System.out.println("10부터 1씩 증가하는 무제한 스트림 중에서 앞에 10개 빼고 최대 10개 까지만");
// todo
System.out.println("자바 수업 중에 Test가 들어있는 수업이 있는지 확인");
// todo
System.out.println("스프링 수업 중에 제목에 spring이 들어간 것만 모아서 List로 만들기");
// todo
}
}
1. 두 수업 목록에 들어있는 모든 수업 아이디 출력
리스트를 항목으로 갖고 있는 것을 Flat 하게 변형한다. → 안에 있는 것들을 다 꺼낸다(?)
FlatMap → 모든 항목들을 풀어내는 것
System.out.println("두 수업 목록에 들어있는 모든 수업 아이디 출력");
ssonEvents.stream().flatMap(Collection::stream)
.forEach(oc -> System.out.println(oc.getId()));
2. 10부터 1씩 증가하는 무제한 스트림 중에서 앞에 10개 빼고 최대 10개 까지만
Stream.iterator → skip, limit
System.out.println("10부터 1씩 증가하는 무제한 스트림 중에서 앞에 10개 빼고 최대 10개 까지만");
Stream.iterate(10, i -> i + 1)
.skip(10)
.limit(10)
.forEach(System.out::println);
3. 자바 수업 중에 Test가 들어있는 수업이 있는지 확인
Match (any, all ,...)
System.out.println("자바 수업 중에 Test가 들어있는 수업이 있는지 확인");
boolean isTestClasses = javaClasses.stream().anyMatch(x -> x.getTitle().contains("Test"));
System.out.println("isTestClasses : " + isTestClasses);4. 스프링 수업 중에 제목에 spring이 들어간 타이틀만 모아서 List로 만들기
System.out.println("스프링 수업 중에 제목에 spring이 들어간 제목만 모아서 List로 만들기");
List<String> springTitleClasses =
springClasses.stream()
.filter(x -> x.getTitle().contains("spring"))
.map(OnlineClass::getTitle)
.collect(Collectors.toList());
springTitleClasses.forEach(x -> System.out.println(" > " + x));🛠 마무리
이렇게 익명클래스, 람다, 함수형 프로그래밍, @FunctionalInterface, 스트림 API, 메서드 레퍼런스에 대해 알아보고 깊게 파보았다.
그러면 질문에 대해 대답해보자.
Q.자바의 람다식은 왜 등장했을까?
자바의 람다식은 함수형 프로그래밍을 자바에 통합하기 위해 자바 8에서 도입됐다. 이는 한 개의 추상 메소드를 가진 인터페이스를 간결하게 구현할 수 있게 해주며, 코드 양을 줄이고 가독성을 향상시키는 이점을 제공한다. 람다식과 익명 클래스는 모두 익명 함수를 구현하는 방식이지만, 람다식은 더 간결한 문법과 함수형 인터페이스의 직접적 사용을 가능하게 한다. 람다식의 도입으로 자바에서도 함수형 프로그래밍 패러다임을 효율적으로 적용할 수 있게 됐다.
람다식은 자바 8에서 처음 소개됐으며, 함수형 프로그래밍 개념을 자바에 도입하기 위한 목적으로 만들어졌다. 익명 클래스에 비해 람다식은 코드를 더 간결하게 만들고, 함수형 인터페이스를 이용해 메소드를 보다 직관적으로 표현할 수 있다. 람다식은 (매개변수) -> { 표현식 } 형태로 작성되며, 이를 통해 인터페이스의 구현체를 더욱 간단하게 작성할 수 있다.
함수형 인터페이스는 단 하나의 추상 메소드를 가지는 인터페이스로, @FunctionalInterface 어노테이션을 사용해 명시적으로 정의할 수 있다. 이 인터페이스는 람다식을 통해 구현될 수 있으며, 자바는 java.util.function 패키지를 통해 다양한 함수형 인터페이스를 제공한다. 이를 통해 개발자는 보다 함수적인 프로그래밍 방식을 자바에서도 적용할 수 있게 됐다.
람다식의 도입은 자바의 내부적인 동작 방식에도 영향을 미쳤다. 람다식은 invokedynamic 바이트코드 명령을 사용해 동적으로 메소드 타입과 메소드 핸들을 결정한다. 이는 람다식이 실행될 때마다 인터페이스의 메소드 호출이 아니라, 실제로 실행되는 함수형 인터페이스의 구현체를 동적으로 생성하고 호출하는 메커니즘을 가능하게 한다. 이 과정은 자바 가상 머신(JVM)의 성능 최적화와 밀접하게 관련되어 있으며, 람다식을 통한 함수형 프로그래밍의 효율적인 실행을 지원한다.
Q. 람다식과 익명 클래스는 어떤 관계가 있을까? - 람다식의 문법은 어떻게 될까?
문법은 위에서 설명을 했으니 위의 질문 혹은 상단 블로그에 참조바랍니다.
람다식과 익명 클래스 모두 인터페이스의 구현체를 생성하는데 사용될 수 있지만, 람다식은 함수형 인터페이스에 한정된다는 점에서 차이가 있다. 람다식은 문법적으로 더 간결하며, 코드를 더 읽기 쉽게 만들어 준다. 반면, 익명 클래스는 여러 메소드를 오버라이드해야 할 때 또는 함수형 인터페이스가 아닌 경우에 여전히 유용하다.
람다식은 자바의 함수형 프로그래밍 패러다임을 강화하는데 기여했으며, 익명 클래스보다 더 간결하고 표현력 있는 코드 작성을 가능하게 한다. 하지만, 익명 클래스는 람다식으로 대체할 수 없는 경우에 여전히 그 가치를 지닌다. 예를 들어, 여러 메소드를 구현해야 하거나, 슈퍼 클래스의 생성자를 호출해야 하는 경우 익명 클래스를 사용해야 한다.
람다식의 도입으로 자바 개발자들은 보다 함수적인 접근 방식을 취할 수 있게 되었고, 이는 자바 프로그래밍 언어의 발전에 중요한 역할을 했다. 익명 클래스와 람다식은 각각의 사용 사례에 따라 선택적으로 사용되어, 자바 프로그래밍의 유연성을 높이는 데 기여한다.
📚 참조
https://dreamchaser3.tistory.com/5
https://www.slideshare.net/DanHeidinga/invokedynamic-evolution-of-a-language-feature
댓글을 작성해보세요.