아이템 42. 익명 클래스보다는 람다를 사용하라

[JoisFe]

아이템 42. 익명 클래스보다는 람다를 사용하라

자바의 함수 타입 표현의 문제점?

• 자바 관련 스터디에서 자바스크립트에 대해 좀 알아보려 한다 (해당 주제의 이해를 위해)

자바스크립트의 일급 함수?

일급 시민 (first class citizen)

• 변수에 담을 수 있다.
• 인자로 전달할 수 있다.
• 반환값으로 전달할 수 있다.

일급 객체

: 객체를 일급 시민으로 취급한다는 것

일급 함수 (first class function)

: 함수를 일급 시민으로 취급한다는 것

자바스크립트의 함수를 인수로 전달하는 예시 (일급 함수)

var numbers = [3, 1, 5, 7];

numbers.sort(function(firstNum, secondNum) {
  return firstNum - secondNum;
});

console.log(numbers);

• 결과를 보면 정렬이 잘 된 것을 알 수 있음
• 정렬을 하는 함수를 인수로 전달하는 것을 확인할 수 있음 -> 일급 함수

자바에서의 일급 함수?

• 자바에서는 일급 함수는 존재하지 않음 즉 함수는 일급 취급을 받지 못함
• 파라미터로 넘기거나 변수에 담을 수도 없고 반환 타입으로도 사용할 수 없다는 것

자바에서 함수를 일급 함수처럼 사용하기 위한 방법

• 자바는 함수를 인수로 전달할 수는 없지만 객체는 전달할 수 있다.
• 즉 자바의 객체는 일급 객체의 특징을 가지는데 객체를 이용하여 위의 문제점을 해결한다.

1. 메서드를 하나 가진 객체를 이용한다.

• 예시를 들어보면 멜론을 타입에 따라 필터, 무게에 따라 필터하는 기능을 구현하려 한다

public interface MelonPredicate {
    boolean test(Melon melon);
}

public class HugeMelonPredicate implements MelonPredicate {

    @Override
    public boolean test(Melon melon) {
        return melon.getWeight() > 5000;
    }
}

public class Melon {

    private final String type;
    private final int weight;
    private final String origin;

    public Melon(String type, int weight, String origin) {
        this.type = type;
        this.weight = weight;
        this.origin = origin;
    }

    public String getType() {
        return type;
    }

    public int getWeight() {
        return weight;
    }

    public String getOrigin() {
        return origin;
    }

    @Override
    public String toString() {
        return "java.Melon{" +
            "type='" + type + '\'' +
            ", weight=" + weight +
            ", origin='" + origin + '\'' +
            '}';
    }
}

public class TastelessMelonPredicate implements MelonPredicate {

    @Override
    public boolean test(Melon melon) {
        return "맛없는 멜론".equalsIgnoreCase(melon.getType());
    }
}

public class Filters {

    public static List<Melon> filterMelons(
        List<Melon> melons, MelonPredicate predicate) {

        List<Melon> result = new ArrayList<>();
        for (Melon melon : melons) {
            if (melon != null && predicate.test(melon)) {
                result.add(melon);
            }
        }
        return result;
    }
}

public class Main {

    public static void main(String[] args) {
        List<Melon> melons = List.of(new Melon("맛좋은 멜론", 5001, "한국"), new Melon("맛없는 멜론", 50, "미국"));

        List<Melon> tastelessMelons = Filters.filterMelons(melons, new TastelessMelonPredicate());

        List<Melon> hugeMelons = Filters.filterMelons(melons, new HugeMelonPredicate());

        System.out.println("맛없는 Melon들은 : ");
        for (Melon melon : tastelessMelons) {
            System.out.println(melon.toString());
        }

        System.out.println();

        System.out.println("huge Melon들은 : ");
        for (Melon melon : hugeMelons) {
            System.out.println(melon.toString());
        }
    }
}

• 위 코드는 Filters 클래스의 filterMelons 메서드가 조건에 따라 필터링을 해주는 기능을 한다
• 필터링을 해주는 조건 메서드를 flterMelons 메서드 인수로 넘기고 싶지만 자바는 불가능 함 (일급 함수가 아니야...)
• 따라서 필터링을 해주는 조건 메서드를 가진 객체를 넘기고자 한다
• 따라서 MelonPredicate 라는 인터페이스를 만들고 test라는 추상 메서드를 둔다
• 해당 필터링 조건을 구현할 구현체 클래스를 만든다 (HugeMelonPredicate, TastelessMelonPredicate)
• 해당 구현체 객체를 인수로 넘긴다면 코드가 깔끔해진다!!

위 방식의 문제점

• 필터링 조건마다 구헌체 클래스를 만들어야 함
• 클래스가 너무 많아짐!! --> 코드와 시간이 많이 듬

해결책

• 자바에서 제공하는 추상 클래스를 이용

2. 이전에 자바에서 함수 타입을 표현할 때 추상 메서드를 하나만 담은 인터페이스(드물게는 추상 클래스)를 사용했음

• 이런 인터페이스의 인스턴스를 함수 객체 (function object) 라고 하여 특정 함수나 동작을 나타내는 데 사용했음
• 1997년 JDK 1.1이 등장하면서 함수 객체를 만드는 주요 수단은 익명 클래스가 되었음

 Collections.sort(words, new Comparator<String>() {
            public int compare(String s1, String s2) {
                return Integer.compare(s1.length(), s2.length());
            }
        }); 

• 위 코드는 문자열을 길이순으로 정렬하기위한 비교 함수로 익명 클래스를 사용한 예이다

이전 멜론 예시를 추상클래스로 리팩토링 해보자

• 먼저 MelonPredicate의 구현체 클래스를 모두 삭제한다

public class Main {

    public static void main(String[] args) {
        List<Melon> melons = List.of(new Melon("맛좋은 멜론", 5001, "한국"), new Melon("맛없는 멜론", 50, "미국"));

        List<Melon> tastelessMelons = Filters.filterMelons(melons, new MelonPredicate() {
            @Override
            public boolean test(Melon melon) {
                return "맛없는 멜론".equalsIgnoreCase(melon.getType());
            }
        });

        List<Melon> hugeMelons = Filters.filterMelons(melons, new MelonPredicate() {
            @Override
            public boolean test(Melon melon) {
                return melon.getWeight() > 5000;
            }
        });

        System.out.println("맛없는 Melon들은 : ");
        for (Melon melon : tastelessMelons) {
            System.out.println(melon.toString());
        }

        System.out.println();

        System.out.println("huge Melon들은 : ");
        for (Melon melon : hugeMelons) {
            System.out.println(melon.toString());
        }
    }
}

• 각각의 필터 조건에 따라 익명클래스를 활용하여 MelonPredicate를 구현한다
• 같은 결과를 확인할 수 있다.
• 여러 클래스를 작성하지 않아도 됨!!

익명 클래스의 문제점

• 여전히 대량의 코드를 작성해야 함..
• 익명 클래스는 상당히 복잡, 초보자에게는 불완전하고 이상해보임
• 위와 같은 문제점으로 인해 자바가 함수형 프로그래밍에 적합하지 않게됨

해결책

• 람다를 사용

3. 익명 클래스보다는 람다를 사용

• 먼저 위의 코드들을 보면 익명 클래스로 변환을 하면서도 MelonPredicate 인터페이스와 같이 추상 메서드 하나짜리 인터페이스는 유지됨
• 이러한 추상 메서드 하나를 가진 인터페이스는 특별한 의미를 인정 받아 특별한 대우를 받음

함수형 인터페이스 (Functional Interface)

• 추상 메서드 하나를 가진 인터페이스
• 이 인터페이스들의 인스턴스를 람다식 (lambda expression) 혹은 람다라고 부르는 것을 사용해 만들 수 있게 됨
• 람다는 함수나 익명 클래스와 개념은 비슷하지만 코드가 훨씬 간결해짐

Collections.sort(words, (s1, s2) -> Integer.compare(s1.length(), s2.length()));

• 위 코드는 이전에 익명 클래스를 이용하여 문자열 길이로 정렬한 예시를 람다를 이용한 것이다.
• 여기서 람다, 매개변수(s1, s2), 반환값의 타입은 각각 (Comparator), String, int 지만 코드에 언급이 없음
• 컴파일러가 문맥을 살펴서 타입을 추론하기 때문에 가능한 일
• 상황에 따라 컴파일러가 타입을 결정하지 못할 수도 있으므로 그러한 경우 직접 명시해줘야 함
• 컴파일러의 타입 추론 규칙은 따로 공부하길 바란다!!!

타입을 명시해야 코드가 더 명확한 경우 혹은 직접 명시해야하는 경우를 제외하고는 람다의 모든 매개변수 타입은 생략하자

• 그래야만 코드를 간단하게 하는 목적을 더욱 달성할 수 있기 때문!!

익명 클래스를 활용하여 리팩토링한 Melon 필터 코드를 람다를 이용하여 리팩토링 해보자

public class Main {

    public static void main(String[] args) {
        List<Melon> melons = List.of(new Melon("맛좋은 멜론", 5001, "한국"), new Melon("맛없는 멜론", 50, "미국"));

        List<Melon> tastelessMelons = Filters.filterMelons(melons, melon -> "맛없는 멜론".equalsIgnoreCase(melon.getType()));

        List<Melon> hugeMelons = Filters.filterMelons(melons, melon -> melon.getWeight() > 5000);

        System.out.println("맛없는 Melon들은 : ");
        for (Melon melon : tastelessMelons) {
            System.out.println(melon.toString());
        }

        System.out.println();

        System.out.println("huge Melon들은 : ");
        for (Melon melon : hugeMelons) {
            System.out.println(melon.toString());
        }
    }
}

• 결과는 동일하면서 훨씬 코드가 간단해 졌음을 확인할 수 있다.

- intellJ IDE 에서도 익명 클래스를 람다로 변환하기를 추천하고 있다.

더 나아가서

• 람다를 언어 차원에서 지원하면서 기존에는 적합하지 않았던 곳에서도 함수 객체를 실용적으로 사용할 수 있게됨

public enum Operation {

    PLUS("+") { @Override public double apply(double x, double y) { return x + y; } },
    MINUS("-") { @Override public double apply(double x, double y) { return x - y; } },
    TIMES("*") { @Override public double apply(double x, double y) { return x * y; } },
    DIVIDE("/") { @Override public double apply(double x, double y) { return x / y; } };

    private final String symbol;

    Operation(String symbol) {
        this.symbol = symbol;
    }

    @Override
    public String toString() {
        return symbol;
    }

    public abstract double apply(double x, double y);

}

• 아이템 32. 제네릭과 가변인수를 함께 쓸 때는 신중하라. #98 Operation 열거 타입 예제 코드에서 apply 메서드 동작이 상수마다 달랐어야 했고 상수별 클래스 몸체를 사용해 각 상수에서 apply 재정의 하였다.
• Melon 필터 예제 코드에서 익명 클래스를 활용한 방식과 매우 유사해 보인다.

public enum Operation {

    PLUS("+", (x, y) -> x + y), 
    MINUS("-", (x, y) -> x - y),
    TIMES("*", (x, y) -> x * y),
    DIVIDE("/", (x, y) -> x / y);

    private final String symbol;
    private final DoubleBinaryOperator op;

    Operation(String symbol, DoubleBinaryOperator op) {
        this.symbol = symbol;
        this.op = op;
    }

    @Override
    public String toString() {
        return symbol;
    }

    public double apply(double x, double y) {
        return op.applyAsDouble(x, y);
    }
}

• 상수별 클래스 몸체를 구현하는 방식보다 열거 타입에 인스턴스 필드를 두는 편이 낫다고 하였음
• 람다를 이용하면 후자의 방식 즉 열거타입의 인스턴스 필드를 이용하는 방식으로 상수별로 다르게 동작하는 코드를 쉽게 구현 가능
• 단순히 각 열거 타입 상수의 동작을 람다로 구현해 생성자에 넘기고 생성자는 이 람다를 인스턴스 필드로 저장
• 이후 apply 메서드에서 필드에 저장된 람다를 호출하기만 하면 됨
• 결론적으로 훨씬 깔끔한 코드가 되었음

주의 사항

• 람다 기반 Operation 코드를 보면 상수별 클래스 몸체는 더 이상 사용할 이유가 없다고 오해할 수 있음
• 하지만 메서드나 클래스와 달리 람다는 이름이 없고 문서화를 하지 못함

따라서 코드 자체로 동작이 명확히 설명되지 않거나 코드 줄 수가 많아진다면 람다를 사용하지 말아야 함!!

• 추상 클래스의 인스턴스를 만들 때 람다를 쓸수 없으니 익명클래스를 사용해야함
• 람다는 자신을 참조할 수 없음
  • 람다에서의 this 키워드는 바깥 인스턴스를 가르킴
  • 익명 클래스에서는 this는 익명 클래스의 인스턴스를 가리킴
  • 따라서 함수 객체가 자신을 참조해야한다면 익명 클래스를 사용해야 함
• 람다도 익명 클래스와 마찬가지로 직렬화 형태가 구현별로 (가령 가상머신별로) 다를 수 있음 따라서 람다를 직렬화 하는 일은 극히 삼가해야함
  • 직렬화 해야하는 함수 객체가 존재한다면 (가령 Comparator 처럼) private 정적 중첩 클래스의 인스턴스를 사용해야함 (아이템 24. 멤버 클래스는 되도록 static으로 만들라 #48)

람다 사용의 기준

• 람다는 한 줄일때 가장 좋고 길어야 세 줄안에 끝나는 것이 좋음
• 그 이상은 가독성이 매우 떨어짐

람다 그 이후

• intelliJ IDE를 보면 람다 코드를 메서드 참조로 수정하는 것을 추천한다.
• 해당 주제는 아이템 43 람다보다는 메서드 참조를 사용하라 라는 주제를 참고하길 바람

정리

• 자바 8로 오면서 작은 함수 객체를 구현하는 데 적합한 ㄹ마다가 도입
• 익명 클래스는 (함수형 인터페이스가 아닌) 타입의 인스턴스를 만들 때만 사용하자
• 람다는 작은 함수 객체를 아주 쉽게 표현할 수 있음 --> 함수형 프로그래밍의 지평을 열었음

Reference

코딩 개념 잡는 자바 코딩 문제집, 길벗, [앵겔 레너드]

[Irisation23]

자바에서 다뤄지는 함수형 프로그래밍의 꽃인 람다와 스트림이 나오기 시작하면서 고민했던 부분이 있습니다.

Java SE 8 - 2014년 3월 18일 발표되고 부터 자바는 함수형 프로그래밍이 사용 가능 해졌습니다.

JavaScript, Scala, Haskell등의 언어처럼 완벽하게 함수형 프로그래밍을 타깃으로한 언어와는 특성이 다르지만 이는 의구심을 가지기에 충분했습니다.

바로 객체지향 언어인 Java는 왜 함수형 프로그래밍을 지원하게 되었는가 입니다.

해당 주제는 생각보다 깊이 생각해야하는 분야였고, 지금의 제가 가진 개발에 관련된 지식에서는 명확하게 정리하기가 쉽지 않다고 생각이 들었습니다. 좋은 레퍼런스를 글쓴이들의 관점에 따라 참조하며 알게된 결론은 시대의 흐름에 의해 프로그래밍의 생태계가 변화했고, 이 변화에 맞춰 자바도 발전했다 정도로 요약해 볼 수 있는것 같습니다.

마지막으로 바뀐 프로그래밍의 생태계 중 핵심 되는 내용은 비동기 논블로킹 방식이 프로그래밍의 핵심 분야로 올라온 덕분이라는 생각이 들었습니다. 스프링에 WebFlux가 도입되게 된 이유도 이와 같다고 생각하고요.

보다 깊은 내용은 아래의 참조 내용을 참조해 보시면 좋을 것 같습니다.

참조 내용

https://tecoble.techcourse.co.kr/post/2021-09-30-java8-functional-programming/
https://wangtak.tistory.com/40
https://warpgate3.tistory.com/entry/%EC%9E%90%EB%B0%94%EC%BD%94%EB%93%9C%EB%A1%9C-%EB%B3%B4%EB%8A%94-%ED%95%A8%EC%88%98%ED%98%95-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D-Functional-Programming-in-Java

[JoisFe]

매우 좋은 고민거리인 것 같습니다
저는 함수형 프로그래밍에 거의 무지하지만
람다와 스트림을 사용하면서 느낀점은 chaning을 통해 코드가 훨씬 간결하고 가독성이 좋아진다는 점 입니다.
또한 알아본바로는 스트림을 이용한 병렬 처리 등을 통해 언급하신 비동기, 논블로킹 방식을 구현할 수 있다는 점 또한 있습니다.
함수형 프로그래밍의 특징은 일반적으로 우리가 생각하는 함수와 다르게

1. 순수 함수가 되어야 한다고 합니다.

• 함수에서 외부의 상태값을 참조하거나 외부의 상태를 변경해서는 안되는 것입니다.

2. 비상태 불변성을 유지

• 함수로 전달된 인자를 변경하지 않아야함
  이로 인해 완전히 독립된 (상호 베타적)이게 되고 side effect를 발생시키지 않기 때문에 멀티 스레딩 영역에서도 안정적이기에 비동기, 논블로킹 방식을 구현할 수 있다고 합니다.

중요한점은 이러한 장점을 취득하기 위해 자바에서 람다와 스트림 등을 지원하게 되었고 객체 지향이 필요한 부분에서는 객체지향을 함수형이 필요한 곳에서는 함수형을 즉 적절한 상황에 맞게 패러다임을 적용해야한다고 합니다.!

[jinan159]

이펙티브자바 앞에 공부했던게 가물가물해서 개인적으로 다시 보고있는데,
JoisFe님 정리 넘 잘읽었습니다.
그리고 저도 Java가 함수형 프로그래밍을 '왜' 지원하게 되었을까에 대해서 깊게 생각해보지 않았는데,
bunsung92님의 덕분에 한번 더 생각하게되어 좋네요~

[JoisFe]

오호 감사합니다.ㅎㅎ
앞으로 저도 스터디 자료를 다시 읽어보는 시간을 가져봐야겠습니다.
(저도 가물가물)