Ch04 리액티브 프로그래밍을 위한 사전 지식

 

4.1 함수형 인터페이스

 

Java 8 부터 함수형 인터페이스 도입

인터페이스가 하나의 추상메서드를 가질 때, 인터페이스를 구현한 구현체를 함수의 파라미터로 전달하는 방식

 

함수형 인터페이스 예시 e.g Comparator<T>

 

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

// 정렬시 인터페이스 구현한 익명 객체 전달
Collections.sort(리스트, new Comparator<Type>() {
    @Override
    public int compare(Type o1, Type o2) {
        return o1.getName().compareTo(o2.getName());
    }
}

 

 

4.2 람다식

 

함수형 인터페이스를 구현한 익명 객체를 람다식으로 간략하게 전달 가능

(람다식의 경우 파라미터 외에도 final 외부 변수를 캡쳐해서 사용 가능함)

 

Collections.sort(리스트, (a, b) -> a.getName().compareTo(b.getName()));

 

 

4.3 메서드 레퍼런스

 

함수형 인터페이스 구현 객체를 람다식으로 축약 가능, 람다식은 다시 메서드 레퍼런스로 간략하게 표현 가능

메서드 레퍼런스 표현 방식 4가지

 

1) ClassName::static method

리스트.stream()
    .map(each -> each.getName())
    //.map(each -> StringUtils.upperCase(each))
    .map(StringUtils::upperCase) // ClassName::static method
    .collect(toList());

 

 

2) ClassName::instance method

 

리스트.stream()
    .map(each -> each.getName())
    //.map(each -> each.upperCase())
    .map(String::upperCase) // ClassName::instance method
    .collect(toList());

 

 

3) Object::instance method (람다 밖에서 선언한 클래스 객체의 메서드를 사용할 때)

Calculator calc = new Calculator();

리스트.stream()
    .map(each -> new ImmutablePair(each.Price(), 2))
    //.map(pair -> calc.multiply(pair))
    .map(calc::multiply)
    .collect(toList());

 

 

4) ClassName::new (생성자)

리스트.stream()
    .map(each -> new ImmutablePair(each.Price(), 2))
    //.map(pair -> new Calculator(pair))
    .map(Calculator::new)
    .map(calc -> calc.multiply()) // 내부적으로 pair 객체를 가졌을 때 multiply 계산
    .findFirst();

4.4 함수 디스크립터

1) interface Predicate<T>

: boolean test(T t) {}, T -> boolean

 

2) interface Consumer<T>

: void accept(T t) {}, T -> void

3) interface Supply<T>

: T get(), void -> T

 

4) interface Function<T, R>

: R apply(T t), T -> R

 

5) BiPredicate<T, U>, BiConsumer<T, U>, BiFunction<T, U, R>