Chapter 03. 람다 표현식

// 익명 클래스 (장황함)
Comparator<Apple> byWeight = new Comparator<Apple>() {
    public int compare(Apple a1, Apple a2) {
        return a1.getWeight().compareTo(a2.getWeight());
    }
};

// 람다 (간결함)
Comparator<Apple> byWeight = (Apple a1, Apple a2) ->
    a1.getWeight().compareTo(a2.getWeight());

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);  // 단 하나의 추상 메서드
}

Predicate<String>  →  String -> boolean
Consumer<Integer>  →  Integer -> void
Function<T, R>     →  T -> R

// Predicate: 조건 검사
Predicate<String> nonEmpty = s -> !s.isEmpty();
filter(list, nonEmpty);

// Consumer: 소비
Consumer<Integer> printer = i -> System.out.println(i);
forEach(list, printer);

// Function: 변환
Function<String, Integer> toLength = s -> s.length();
map(list, toLength);  // ["abc", "de"] -> [3, 2]

// 박싱 발생 (비효율)
Predicate<Integer> p1 = i -> i > 0;

// 박싱 없음 (효율)
IntPredicate p2 = i -> i > 0;

// 1. 함수형 인터페이스 정의
@FunctionalInterface
public interface BufferedReaderProcessor {
    String process(BufferedReader br) throws IOException;
}

// 2. 동작을 인수로 받는 메서드
public String processFile(BufferedReaderProcessor p) throws IOException {
    try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
        return p.process(br);  // 전달받은 동작 실행
    }
}

// 3. 다양한 동작 전달
String oneLine = processFile(br -> br.readLine());
String twoLines = processFile(br -> br.readLine() + br.readLine());

// filter의 두 번째 파라미터가 Predicate<Apple> → 대상 형식
List<Apple> result = filter(inventory, (Apple a) -> a.getWeight() > 150);

Callable<Integer> c = () -> 42;
PrivilegedAction<Integer> p = () -> 42;
// 같은 람다지만 대상 형식이 다름

// 형식 명시
Comparator<Apple> c = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

// 형식 추론 (더 간결)
Comparator<Apple> c = (a1, a2) -> a1.getWeight().compareTo(a2.getWeight());

int portNumber = 1337;
Runnable r = () -> System.out.println(portNumber);  // 외부 변수 캡처

int portNumber = 1337;
Runnable r = () -> System.out.println(portNumber);
portNumber = 31337;  // 컴파일 에러! 값 변경 불가

// 람다
inventory.sort((a1, a2) -> a1.getWeight().compareTo(a2.getWeight()));

// 메서드 참조
inventory.sort(comparing(Apple::getWeight));

// 1. 정적 메서드 참조
Function<String, Integer> f = Integer::parseInt;
// 동일: Function<String, Integer> f = s -> Integer.parseInt(s);

// 2. 임의 객체의 인스턴스 메서드
Function<String, Integer> f = String::length;
// 동일: Function<String, Integer> f = s -> s.length();

// 3. 특정 객체의 인스턴스 메서드
Supplier<Integer> s = apple::getWeight;
// 동일: Supplier<Integer> s = () -> apple.getWeight();

ClassName::new

// 인수 없는 생성자
Supplier<Apple> c1 = Apple::new;
Apple a1 = c1.get();

// 인수 1개 생성자
Function<Integer, Apple> c2 = Apple::new;  // Apple(Integer weight)
Apple a2 = c2.apply(110);

// 인수 2개 생성자
BiFunction<Color, Integer, Apple> c3 = Apple::new;  // Apple(Color, Integer)
Apple a3 = c3.apply(GREEN, 110);

// 활용: 리스트 → 객체 리스트
List<Integer> weights = Arrays.asList(7, 3, 4, 10);
List<Apple> apples = map(weights, Apple::new);

// 1. 익명 클래스
Comparator<Apple> c = new Comparator<Apple>() {
    public int compare(Apple a1, Apple a2) {
        return a1.getWeight().compareTo(a2.getWeight());
    }
};

// 2. 람다 (형식 명시)
Comparator<Apple> c = (Apple a1, Apple a2) ->
    a1.getWeight().compareTo(a2.getWeight());

// 3. 람다 (형식 추론)
Comparator<Apple> c = (a1, a2) ->
    a1.getWeight().compareTo(a2.getWeight());

// 4. 메서드 참조
Comparator<Apple> c = comparing(Apple::getWeight);