[ Java ] 24. 익명클래스보다는 람다

익명 클래스보다는 람다

---

자바에서 함수 타입을 표현할 때는 추상 메서드를 하나만 담은 인터페이스(또는 추상 클래스)를 사용했다. 이러한 인터페이스의 인스턴스를 함수 객체라고 해서 특정 함수나 동작을 나타내는데 썼다.

 

익명 클래스

JDK 1.1 버전부터 함수 객체를 만들 때 익명 클래스(Anonymous Class)를 주로 사용했다. 하지만 익명 클래스 방식은 코드가 너무 길기 때문에 이 떄까지의 자바는 함수형 프로그래밍에 적합하지 않았다.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> Words = Arrays.asList("APPLE", "Banana", "orange", "korea");

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

 

람다

JDK 1.8 버전부터 추상 메서드 하나 짜리 인터페이스, 즉 함수형 인터페이스를 말하는데 그 인터페이스의 인스턴스를 람다식(lambda expression)으로 사용해서 만들 수 있게 되었다.

• 기본적인 람다식 구조

// ( 매개변수 ) -> { 표현식 };
(int a, int b) -> { return a + b; }
(String str) -> System.out.println(str);

• 메소드 참조 표현식 -> ::

// 람다식에서 파라미터를 중복해서 사용하기 싫을 경우 사용한다.
// 람다표현식에서만 사용 가능 하며 이름만으로 특정 메소드를 호출할 수 있는 기능이다.

// 기존
stream.forEach(e -> System.out.println(e));
// ::
stream.forEach(System.out::pri\ntln);

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> Words = Arrays.asList("APPLE", "Banana", "orange", "korea");

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

여기서 람다의 타입은Comparator<String> 이고 매개변수 (s1, s2)의 타입은 String이며 반환 값의 타입은 int이다.

 

하지만 컴파일러가 코드의 문맥을 살펴서 타입추론을 했기 때문에 코드 상에는 이 타입들이 명시되어 있지 않다. 타입을 명시해야 코드가 명확할 때를 제외하고는 람다의 모든 매개변수 타입은 생략하고 상황에 따라서 컴파일러가 타입을 결정하지 못해서 오류가 발생할 때는 타입을 명시하면 된다.

 

컴파일러가 타입을 추론할 떄 필요한 정보들은 대부분 제네릭을 통해서 얻게 된다.

위 코드는 아래처럼 더 간단하게 표현할 수 있다.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> Words = Arrays.asList("APPLE", "Banana", "orange", "korea");

        Collections.sort(Words, Comparator.comparingInt(String::length));
    }
}

더 나아가서 JDK 1.8 이상을 사용하면 List 인터페이스에 추가된 sort 메서드를 사용할 수 있다.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> Words = Arrays.asList("APPLE", "Banana", "orange", "korea");
        Words.sort(Comparator.comparingInt(String::length));
    }
}

 

- 열거타입에서의 람다

enum Operation {
    PLUS("+") {
        public double apply(double x, double y) { return x + y; }
    },
    MINUS("-") {
        public double apply(double x, double y) { return x - y; }
    },
    TIMES("*") {
        public double apply(double x, double y) { return x * y; }
    },
    DIVIDE("/") {
        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);
}

열거 타입에서 람다를 이용하면 열거 타입의 인스턴스 필드를 이용하는 방식으로 상수별로 다르게 동작하는 코드를 쉽게 구현할 수 있다.

import java.util.function.DoubleBinaryOperator;

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);
    }
}

public class Main {
    public static void main(String[] args) {
        Operation.PLUS.apply(2, 3);
    }
}

DoubleBinaryOperator는 java.util.function 패키지에 있는 Double 타입 인수를 2개 받아서 Double 타입 결과를 반환해주는 인터페이스이다.

 

람다의 한계

1. 추상클래스의 인스턴스를 만들 때는 람다사용 불가능
2. 추상메서드가 여러개인 인터페이스의 인스턴스로 람다 표현 불가능
3. 람다의 this는 바깥의 인스턴스를 가리킨다.

람다를 무조건적으로 사용하는 것은 좋지 않은 경우도 있다.

 

람다는 이름도 없고, 메서드나 클래스와 다르게 문서화도 할 수 없기 때문에 코드 자체로 동작이 명확하게 설명되지 않거나 코드 라인 수가 많아지면 사용하는 것을 고려해봐야 한다.

 

람다가 너무 길거나 읽기 어렵다면 오히려 쓰지 않는 방향으로 리팩토링 하는 것을 권장한다.

그리고 추상 클래스의 인스턴스를 만들 때 람다를 사용할 수 없다. 이 때는 익명클래스를 사용해야 한다.

abstract class Hello {
    public void sayHello() {
        System.out.println("Hello!");
    }
}

public class Main {
    public static void main(String[] args) {
        // 이건 원래 안된다
        // Hello hello = new Hello();

        Hello instance1 = new Hello() {
            private String msg = "Hi";
            @Override
            public void sayHello() {
                System.out.println(msg);
            }
        }

        Hello instance2 = new Hello() {
            private String msg = "HolaHola";
            @Override
            public void sayHello() {
                System.out.println(msg);
            }
        }

        instance1.sayHello(); // Hi
        instance2.sayHello(); // HolaHola

        System.out.println(instance1 == instance2); // false
    }
}

또한, 람다는 자기 자신 참조가 안된다. this 키워드는 바깥의 인스턴스를 가리키게 된다.

 

반면에 익명클래스에서의 this는 익명 클래스의 인스턴스 자신을 가리킨다.

import java.util.*;

class Anonymous {
    public void say() {}
}

public class Main {
    public void testMethod() {
        List<Anonymous> list = Arrays.asList(new Anonymous());

        Anonymous anonymous = new Anonymous() {
            @Override
            public void say() {
                System.out.println("this instanceof Anonymous : " + (this instanceof Anonymous));
            }
        };

        anonymous.say(); // this instanceof Anonymous : true

        // this instanceof Main : true
        list.forEach(o -> System.out.println("this instanceof Main: " + (this instanceof Main)));
    }

    public static void main(String[] args) {
        new Main().someMethod();
    }
}

람다도 익명 클래스와 동일하게 직렬화(Serialization)의 형태가 구현별(ex. 가상머신)로 다를 수 있으므로 주의해야 한다.

Comparator처럼 직렬화해야만 하는 함수 객체가 있으면 private static 중첩 클래스의 인스턴스를 사용하면 된다.

 

참조

https://madplay.github.io/post/prefer-lambdas-to-anonymous-classes