출처
https://www.baeldung.com/java-functional-programming
책 - 모던자바인액션
1. 소개
이 튜토리얼에서 우리는 함수형 프로그래밍 패러다임의 핵심 원칙과 자바 프로그래밍 언어에서 이를 실행하는 방법을 이해하고, 고급 함수형 프로그래밍 기술 중 일부를 다뤄볼 것입니다.
2. 함수형 프로그래밍이란?
함수형 프로그래밍은 기본적으로 수학의 함수처럼 컴퓨터 프로그램을 작성하는 스타일을 말합니다. 그렇다면 수학에서 함수란 무엇일까요? 함수는 입력 집합을 출력 집합에 연결하는 표현식인데, 여기서 중요한 것은 함수의 출력은 입력에만 의존한다는 것입니다.
from 모던자바인액션 책
- 함수란 수학적인 함수와 같다. 즉, 함수는 0개 이상의 인수를 가지며, 한 개 이상의 결과를 반환하지만 부작용이 없다.
- 함수나 메서드는 지역 변수만을 변경해야 함수형이라 할 수 있다. 그러나 함수나 메서드에서 참조하는 객체가 있다면 그 객체는 불변 객체여야 한다. 즉, 객체의 모든 필드가 final이어야 한다는 것.
- 함수형은 함수나 메서드가 어떤 예외도 일으키지 않아야 한다. 예외가 발생하면 return으로 결과를 반환할 수 없게 되는데 수학적 함수는 함수값에 대응하는 하나의 결과를 반환해야 한다.
- 선언적 프로그래밍과 함수형 프로그래밍의 비교하자면 선언적 프로그래밍은 '어떻게(how)에 집중하는 반편 함수형은 '무엇을'에 집중한다. 스트림 API를 이용해 구현 방법은 라이브러리가 결정한다.
//선억적 프로그래밍
Transaction mostExpensive = transaction.get(0);
if (mostExpensive == null)
throw new IllegalArgumentException("Empty list of trancsactions")
for (Transaction t : transactions.subList(1, transactions.size())) {
if (t.getValue() > mostExpensive.getValue()) {
mostExpensive = t;
}
}
//함수형 프로그래밍
Optional<Transaction> mostExpensive = transactions.stream().max(comparing(Transaction::getValue));
2.1. 프로그래밍 패러다임의 분류
대체로 프로그래밍 스타일은 명령형 프로그래밍 패러다임과 선언적 프로그래밍 패러다임으로 분류할 수 있습니다. 명령형 접근 방식은 프로그램을 최종 상태에 도달할 때까지 프로그램의 상태를 변경하는 일련의 명령문으로 정의합니다. 절차적 프로그래밍은 절차나 서브루틴을 사용하여 프로그램을 구성하는 명령형 프로그래밍의 한 유형입니다. 객체 지향 프로그래밍(OOP)으로 알려진 인기 있는 프로그래밍 패러다임 중 하나는 절차적 프로그래밍 개념을 확장한 것입니다. 대조적으로, 선언적 접근 방식은 일련의 명령문으로 제어 흐름을 설명하지 않고 계산 논리를 표현합니다. 간단히 말해서, 선언적 접근 방식의 초점은 프로그램이 달성해야 하는 방법보다는 프로그램이 달성해야 하는 것을 정의하는 것입니다. 함수형 프로그래밍은 선언적 프로그래밍 언어의 하위 집합입니다. 오늘날 인기 있는 프로그래밍 언어의 대부분은 범용 언어이므로 여러 프로그래밍 패러다임을 지원하는 경향이 있다는 것을 이해하는 것이 중요합니다.
3. 기본 원칙 및 개념
이 섹션에서는 함수형 프로그래밍의 몇 가지 기본 원칙과 이를 Java에 적용하는 방법을 다룹니다. 우리가 사용할 많은 기능이 항상 Java의 일부가 아니어서 함수형 프로그래밍을 효과적으로 실행하기 위해선 Java 8 이상을 사용하는 게 좋습니다.
3.1. 일급 및 고차 함수
프로그래밍 언어는 함수를 일급 시민(first-citizen)으로 취급하는 경우 일급 함수를 갖는다고 합니다. 함수를 변수에 할당하고, 다른 함수에 인수로 전달하고, 다른 함수의 값으로 반환하는 것이 포함됩니다. 이 속성을 사용하면 함수형 프로그래밍에서 고차 함수를 정의할 수 있습니다. 고차 함수는 함수를 인수로 받고 결과로 함수를 반환할 수 있습니다. 이를 통해 함수 구성 및 커링과 같은 함수 프로그래밍의 여러 기술을 추가로 사용할 수 있습니다.
- 함수를 마치 일반값처럼 사용해서 인수로 전달하거나, 결과로 반환받거나, 자료구조에 저장할 수 있음을 의미
- 자바 8이 이전 버전과 구별되는 특징 중 하나가 일급 함수를 지원한다는 점인데 :: 연산자로 메서드 참조를 만들거나 (int x) -> x + 1 같은 람다 표현식으로 직접 함숫값을 표현해서 메서드를 함숫값으로 사용할 수 있습니다.
Collections.sort 메서드에 사용자 지정 비교기를 제공해야 한다고 가정해 보겠습니다. 아래의 코드는 우리가 볼 수 있듯이 이것은 지루하고 장황한 기술입니다.
Collections.sort(numbers, new Comparator<Integer>() {
@Override
public int compare(Integer n1, Integer n2) {
return n1.compareTo(n2);
}
});
Collections.sort(numbers, (n1, n2) -> n1.compareTo(n2));
Java는 람다식을 Object로 취급하는데 이건 사실 Java의 진정한 1급 시민입니다.
3.2. 순수 함수
순수 함수는 오직 argument만을 기반으로 값을 반환해야 하며 side-effect가 없는것을 강조합니다. 이것은 Java의 모든 best practice와 상당히 반대되는 것처럼 들릴 수 있습니다.
객체 지향 언어인 Java는 핵심 프로그래밍 방식으로 캡슐화를 권장합니다. 개체의 내부 상태를 숨기고 액세스 및 수정에 필요한 메서드만 노출되는 것을 권장합니다. 따라서 이러한 메서드는 엄격하게 순수한 함수는 아닙니다.
물론 캡슐화 및 기타 객체 지향 원칙은 권장 사항일 뿐 Java에서 바인딩되지 않습니다. 사실, 개발자들은 최근에 불변 상태 정의의 가치와 side-effect가 없는 메소드의 가치를 깨닫기 시작했습니다.
Integer sum(List<Integer> numbers) {
return numbers.stream().collect(Collectors.summingInt(Integer::intValue));
}
이제 이 방법은 받는 인수에만 의존하며 어떠한 부작용도 일으키지 않습니다.
부작용은 메서드의 의도된 동작을 제외하고 무엇이든 될 수 있습니다. 예를 들어, 부작용은 값을 반환하기 이전에 local 또는 global 상태를 업데이트하거나 데이터베이스에 저장하는 것을 말할 수 있습니다. 순수주의자들은 또한 로깅도 부작용으로 취급하지만 우리 모두는 우리 만의 룰이 있습니다. 하지만 실제로 결과를 데이터베이스에 저장해야 할 수도 있습니다. 함수형 프로그래밍에는 순수한 함수를 유지하면서 부작용을 처리하는 기술이 있습니다.
3.3. 불변성
불변성은 함수형 프로그래밍의 핵심 원리 중 하나로, 엔터티를 인스턴스화한 후에는 수정할 수 없는 속성을 말합니다. 함수형 프로그래밍 언어에서는 이는 언어 수준(Language level)에서 지원되는데 자바에서는 변경할 수 없는 데이터 구조를 만들기 위해 스스로 결정해야 합니다.
Java 자체는 String과 같은 몇 가지 기본 제공 불변 유형을 제공합니다. 이것은 주로 보안상의 이유입니다. 클래스 로딩에서 String을 많이 사용하고 해시 기반 데이터 구조에서 키로 사용하기 때문입니다. 기본 래퍼(primitive wrapper) 및 수학 유형과 같은 몇 가지 다른 기본 제공 불변 유형이 있습니다.
그러나 우리가 Java에서 생성하는 데이터 구조는 어떻습니까? 물론, 그것들은 기본적으로 변하지 않고,, 불변성을 달성하기 위해 몇 가지를 변경해야 합니다. final 키워드의 사용은 그 중 하나이지만 여기서 그치지 않습니다.
public class ImmutableData {
private final String someData;
private final AnotherImmutableData anotherImmutableData;
public ImmutableData(final String someData, final AnotherImmutableData anotherImmutableData) {
this.someData = someData;
this.anotherImmutableData = anotherImmutableData;
}
public String getSomeData() {
return someData;
}
public AnotherImmutableData getAnotherImmutableData() {
return anotherImmutableData;
}
}
public class AnotherImmutableData {
private final Integer someOtherData;
public AnotherImmutableData(final Integer someData) {
this.someOtherData = someData;
}
public Integer getSomeOtherData() {
return someOtherData;
}
}
- 불변 데이터 구조의 모든 필드는 불변이어야 합니다.
- 이것은 모든 중첩 유형과 컬렉션 (컬렉션에 포함한 것들까지)에도 적용되야 합니다.
- 초기화를 위한 하나 이상의 생성자가 있어야 합니다.
- 부작용 없는 접근자 메서드만 있어야 합니다.
항상 정확하게 원칙을 고수하긴 어렵다. 특히 데이터 구조가 복잡해지면 복잡해질수록.. 그러나 여러 외부 라이브러리를 사용하면 Java에서 immutable data를 더 쉽게 사용할 수 있습니다. 예를 들면 Immutables 및 Project Lombok은 Java에서 변경할 수 없는 데이터 구조를 정의하기 위해 도움을 줍니다.
3.4. 참조 투명성
참조 투명성은 아마 이해하기 어려운 함수형 프로그래밍 원칙 중 하나일 것입니다. 그러나 개념은 매우 간단합니다. 함수 외부의 영향을 받지 않는 것입니다. (= 함수의 결과는 입력 파라미터에만 의존하고, 함수 외 DB, 파일시스템, 원격 URL 등에서 데이터를 읽어 오지 않음 = 외부와 의존적이지 않은 코드 = 동일한 매개변수에 대해서는 항상 동일한 결과 = 예외가 없음) 이를 통해 고차 함수 및 지연 평가와 같은 함수형 프로그래밍에서의 몇 가지 강력한 기술을 사용할 수 있습니다. 이것을 더 잘 이해하기 위해 예를 들어 보겠습니다.
public class SimpleData {
private Logger logger = Logger.getGlobal();
private String data;
public String getData() {
logger.log(Level.INFO, "Get data called for SimpleData");
return data;
}
public SimpleData setData(String data) {
logger.log(Level.INFO, "Set data called for SimpleData");
this.data = data;
return this;
}
}
이것은 Java의 일반적인 POJO 클래스이지만 이것이 참조 투명성을 제공하는지 확인하는 데 관심이 있습니다. 다음 진술을 관찰합시다.
String data = new SimpleData().setData("Baeldung").getData();
logger.log(Level.INFO, new SimpleData().setData("Baeldung").getData());
logger.log(Level.INFO, data);
logger.log(Level.INFO, "Baeldung");
logger에 대한 세 번의 호출은 의미상 동일하지만 참조적으로 투명하지 않습니다. 첫 번째 호출은 부작용을 생성하므로 참조적으로 투명하지 않습니다. 이 호출을 세 번째 호출에서와 같이 해당 값으로 바꾸면 로그가 누락됩니다.
두 번째 호출도 SimpleData가 변경 가능하므로 참조적으로 투명하지 않습니다. 프로그램의 어느 곳에서나 data.setData를 호출하면 해당 값으로 대체되기가 어렵습니다.
따라서 기본적으로 참조 투명성을 위해서는 순수하고 변경할 수 없는 함수가 필요합니다. 이것은 우리가 이미 앞에서 논의한 두 가지 전제 조건입니다. 참조 투명성의 흥미로운 결과로써 우리는 컨텍스트가 없는 코드를 생산합니다. 다시 말해서, 우리는 해당 코드를 어떤 순서와 컨텍스트로든 실행할 수 있으며, 이는 다른 최적화 가능성으로 이어지게 됩니다.
4. 함수형 프로그래밍 기법
앞에서 논의한 함수형 프로그래밍 원칙을 통해 함수형 프로그래밍의 이점을 얻기 위한 여러 기술을 사용할 수 있습니다. 이 섹션에서는 이런 인기 기술 중 일부를 다루고 이를 Java에서 구현하는 방법을 이해해 보겠습니다.
4.1. 기능 구성
Function Composition은 단순한 함수를 결합하여 복잡한 함수를 구성하는 것을 말합니다. 이것은 실제로 자바의 funcional 인터페이스를 통해 달성됩니다.
일반적으로 단일 추상 메서드가 있는 모든 인터페이스는 functional 인터페이스로 사용할 수 있습니다. 그러므로 우리는 functional 인터페이스를 꽤나 쉽게 정의할 수 있지만 Java 8은 기본적으로 java.util.function 패키지에서 다양한 사용 사례에 대해 많은 기능적 인터페이스를 제공하고 있습니다.
이것을 더 잘 이해하기 위해 Function 인터페이스를 예로 들어보면 Function은 하나의 인수를 받아들이고 결과를 생성하는 간단하고 일반적인 기능의 인터페이스입니다.
또한 함수 구성에 도움이 되는 두 가지 기본 메서드인 compose 및 andThen을 제공합니다.
Function<Double, Double> log = (value) -> Math.log(value);
Function<Double, Double> sqrt = (value) -> Math.sqrt(value);
Function<Double, Double> logThenSqrt = sqrt.compose(log);
logger.log(Level.INFO, String.valueOf(logThenSqrt.apply(3.14)));
// Output: 1.06
Function<Double, Double> sqrtThenLog = sqrt.andThen(log);
logger.log(Level.INFO, String.valueOf(sqrtThenLog.apply(3.14)));
// Output: 0.57
이 두 가지 방법 모두 여러 함수를 단일 함수로 구성할 수 있게 하지만 다른 의미를 제공합니다. compose는 인수에 전달된 함수를 먼저 적용한 다음 호출된 함수를 적용하고 andThen은 역으로 동일한 작업을 수행합니다.
여러 다른 함수형 인터페이스도 funcion composition에 사용될 여러 흥미로운 메소드를 가지고 있는데 Predicate 인터페이스의 기본 페소드 and, or, negate가 있습니다. 이러한 기능적 인터페이스는 단일 인수를 허용하지만 BiFunction 및 BiPredicate와 같은 2개의 인수도 가능하게 합니다.
4.2. 모나드 (추가 리서치 필요 - 이해 X)
공식적으로 모나드는 일반적으로 프로그램을 구조화할 수 있는 추상화입니다. 따라서 기본적으로 모나드는 값을 래핑하고, 일련의 변환을 적용하고, 모든 변환이 적용된 값을 돌려 받을 수 있게 합니다. (a monad allows us to wrap a value, apply a set of transformations, and get the value back with all transformations applied.)물론 모든 모나드가 따라야 하는 세 가지 법칙(왼쪽 항등, 오른쪽 항등, 연관성)이 있지만 자세한 내용은 다루지 않겠습니다.
Java에는 Optional 및 Stream과 같이 자주 사용하는 몇 가지 모나드가 있습니다.
Optional.of(2).flatMap(f -> Optional.of(3).flatMap(s -> Optional.of(f + s)))
Optional 을 모나드라고 부르는 이유는 무엇일까요? 여기에서 Optional을 사용하면 of를 사용해 값을 래핑하고 flatMap 메서드를 사용하여 다른 래핑된 값을 추가하는 변환을 적용하고 있습니다
원한다면 Optional이 모나드의 세 가지 법칙을 따른다는 것을 보여줄 수 있습니다. 그러나 비평가들은 Optional이 어떤 상황에선 모나드 법칙을 어긴다고 지적할 것입니다. 그러나 대부분의 실제 상황에서는 이 정도면 충분합니다.
모나드의 기본 사항을 이해한다면 Stream 및 CompletableFuture와 같은 Java에 다른 많은 예제도 있음을 깨닫게 될 것입니다. 우리는 로그(log) 모나드, 보고(report) 모나드 또는 감사(audit) 모나드와 같은 다양한 목표를 달성하기 위해 Java에서 자체 모나드 유형을 정의할 수 있습니다. 함수형 프로그래밍에서 부작용 처리(side-effect)에 대해 논의한 것을 기억하십니까? 모나드는 그것을 달성하기 위한 함수형 프로그래밍 기술 중 하나인 것처럼 보이네요.
4.3. 커링 (Currying)
Currying은 여러 인수를 취하는 함수를 단일 인수를 취하는 일련의 함수로 변환하는 수학적 기술입니다. 우리는 왜 함수형 프로그래밍에서 이 기술이 필요할까요? 모든 인수를 이용해 함수를 호출할 필요가 없는, 강력한 구성 기술을 제공하기 때문입니다.
게다가 커링 함수는 모든 인수를 받을 때까지 그 효과를 깨닫지 못합니다.
Haskell과 같은 순수 함수형 프로그래밍 언어에서는 커링이 잘 지원됩니다. 사실, 모든 함수는 기본적으로 커링이 됩니다. 그러나 Java에서는 그렇게 간단하지 않습니다.
Function<Double, Function<Double, Double>> weight = mass -> gravity -> mass * gravity;
Function<Double, Double> weightOnEarth = weight.apply(9.81);
logger.log(Level.INFO, "My weight on Earth: " + weightOnEarth.apply(60.0));
Function<Double, Double> weightOnMars = weight.apply(3.75);
logger.log(Level.INFO, "My weight on Mars: " + weightOnMars.apply(60.0));
위 코드는 우리는 행성에서 우리의 무게를 계산하는 함수를 정의한 것입니다. 우리의 질량은 동일하게 유지되지만 중력은 우리가 있는 행성에 따라 다릅니다. 특정 행성에 대한 함수를 정의하기 위해 중력만 전달하여 함수를 부분적으로 적용할 수 있습니다. 또한 이 부분적으로 적용된 함수를 임의의 구성에 대한 인수 또는 반환 값으로 전달할 수 있습니다.
Currying은 람다 식과 클로저라는 두 가지 기본 기능에 기초를 둡니다. 람다 표현식은 코드를 데이터로 취급하는 데 도움이 되는 익명 함수입니다. 우리는 이전에 기능적 인터페이스를 사용하여 구현하는 방법을 보았습니다.
이제 람다 식은 우리가 클로저로 정의하는 어휘 범위에서 닫힐 수 있습니다. 예를 들어 보겠습니다.
private static Function<Double, Double> weightOnEarth() {
final double gravity = 9.81;
return mass -> mass * gravity;
}
위의 메서드에서 반환하는 람다 식이 어떻게 우리가 클로저라고 부르는 둘러싸는 변수에 의존하는지 주목하십시오. 다른 함수형 프로그래밍 언어와 달리 Java는 둘러싸는 범위가 최종적이거나 사실상 최종적이어야 한다는 제한이 있습니다.
흥미로운 결과로, 커링을 사용하면 Java에서 임의의 arity의 기능적 인터페이스를 만들 수도 있습니다.
from 모던자바인액션
예를 들어, 섭씨를 화씨로 변환하는 공식이 있다고 치자.
CtoF(x) = x*9/5 + 32
이것을 메서드로 표현하면
static double converter(double x, double f, double b) {
return x * f + b;
}
x는 변환하려는 값, f는 변환요소, b는 기준치 조정 요서인데 온도뿐 아니라 킬로미터와 마일 등의 단위도 변환해야 할 것이다. 기존 로직을 커링이라는 개념을 활용해서 한 개의 인수를 갖는 변환 함수를 생산하는 '팩토리'를 정의해보자
static DoubleUnaryOperator curriedConverter(double f, double b) {
return (double x) -> x * f + b;
}
DoubleUnaryOperator converterCtoF = curriedConverter(9.0/5, 32);
DoubleUnaryOperator convertUSDtoGBP = curriedCOnverter(0.6, 0);
DoubleUnaryOperator convertKmtoMi = curriedConverter(0.6214, 0);
double gbp = convertUSDtoGBP.applyAsDouble(1000);
기존의 변환 로직을 재활용하는 유연한 코드를 얻었다.
참고로, DoubleUnaryOperator는 applyAsDouble 이라는 메서드를 정의한다.
4.4. 재귀
재귀는 문제를 작게 나누는데 도움을 주는 좋은 기술입니다. 재귀의 주요 이점은 side-effect를 제거하는 데도 도움됩니다.
from 모던자바인액션
순수 함수형 프로그래밍 언어에서는 while, for 같은 반복문을 포함하지 않는다. 그런 함수형 프로그래밍의 장점이 분명히 있지만 무조건 반복보다는 재귀가 좋다고 주장은 옳지 않다. 왜냐하면 반복 코드보다 재귀 코드가 더 비싸기 때문, 재귀함수를 호출할 때마다 호출 스택에 각 호출시 생성되는 정보를 저장할 새로운 스택 프레임이 만들어진다. 즉, 재귀 팩토리얼의 입력값에 비례해서 메모리 사용량이 증가한다. 그러면 어떡할까? 함수형 언어에서는 '꼬리 호출 최적화' 라는 해결책을 제공한다.
// 일반 재귀 방식의 팩토리얼
static long factorialRecursive(long n) {
return n == 1 ? 1 : n * factorialRecursive(n-1);
}
// 꼬리 재귀 팩토리얼
static long factorialTailRecursive(long n) {
return factorialHelper(1, n);
}
static long factorialHelper(long acc, long n) {
return n == 1 ? acc : factorialHelper(acc * n, n-1);
}
컴파일러가 하나의 스택 프레임을 재활용할 가능성이 생긴다. 재귀 호출 이후 추가적인 연산을 요구하지 않도록 구현하는 것이 핵심이다. 아쉽게도 자바는 이와 같은 최적화를 재공하지 않는다, 하지만 여러 컴파일러 최적화 여지를 남겨둘 수 있는 꼬리재귀를 이용하는 것이 좋다.
5. 함수형 프로그래밍이 왜 중요한가?
Java를 포함한 모든 언어에서 함수형 프로그래밍을 채택할 때의 가장 큰 이점은 순수 함수와 불변 상태입니다. 돌이켜 생각해보면 대부분의 프로그래밍 문제는 부작용과 변경 가능한 상태가 원인이 되고 있습니다. 따라서 그것들을 제거하기만 하면 우리 프로그램을 더 쉽게 읽고, 추론하고, 테스트하고, 유지 관리할 수 있습니다.
선언적 프로그래밍의 하위 집합인 함수형 프로그래밍은 고차 함수, 함수 구성 및 함수 연결과 같은 여러 구문을 제공합니다. Stream API가 데이터 조작을 처리하기 위해 Java 8에 가져온 이점을 생각해 보십시오.
함수형 프로그래밍을 사용하기 시작하기 전에 우리는 프로그램에 대해 함수 측면에서 생각하도록 훈련해야 합니다.
6. 자바는 함수형 프로그래밍에 적합 할까요?
Java에 진정한 함수 타입이 없다는 것은 함수형 프로그래밍의 기본 원칙에 위배됩니다. lamda expression으로 위장한 기능적 인터페이스는 적어도 구문적으로는 대부분 이를 보완하긴 하지만 Java가 기본적으로 mutable하고, immutable 타입으로 변경하려면 너무나도 많은 상용구를 작성해야 하는 것도 사실입니다.
Java에서 arguments에 대한 기본 전략은 eager이지만 lazy evalauation은 더 효과적이고 함수형 프로그래밍에서 추천되는 전략입니다. 우리는 연산자 단락 및 기능 인터페이스를 사용하여 Java에서 지연 평가를 달성할 수 있지만 더 복잡합니다.
type-erasure, 꼬리호출 최적화 등등이 완성된 형태가 아니기 때문에 Java는 함수형 프로그래밍에서 처음부터 프로그램을 시작하는 데 적합하지는 않습니다.
그러나 이미 Java로 작성된 기존 프로그램이 있는 경우(아마도 객체 지향 프로그래밍으로) 어떻게 될까요? 특히 Java 8에서 함수형 프로그래밍의 이점을 취하는 데에는 문제가 없겠습니다.
함수형 프로그래밍의 대부분의 이점은 Java 개발자에게 달려있습니다. 객체 지향 프로그래밍과 함수형 프로그래밍의 이점을 결합하면 먼 길도 쉽게 갈 수 있을 것입니다.
7. 결론
이 튜토리얼에서는 함수형 프로그래밍의 기초를 살펴보았습니다. 우리는 기본 원칙과 Java에서 이를 채택하는 방법을 다루었습니다. 또한 Java의 예제를 사용하여 함수형 프로그래밍에서 몇 가지 인기 있는 기술에 대해 논의했습니다.
마지막으로, 우리는 함수형 프로그래밍을 채택할 때의 이점 중 일부를 다루었고 Java가 이에 적합한지 답했습니다.
'책 > 모던자바인액션' 카테고리의 다른 글
| 자바의 '람다표현식' 어떻게 만드는지, 어떻게 사용하는지, 어떻게 코드를 간결하게 만들 수 있는지 (0) | 2022.06.21 |
|---|