class  implements Comparator<String> {
    public int compare(String first, String second) {
        return Integer.compare(first.length(), second.length());
    }
}
Arrays.sort(strings, new LengthComparator());

// After
(String first, String second) -> Integer.compare(first.length(), second.length());

// Runnable 함수형 인터페이스 (참고용)
public interface Runnable {
    void run();
}

// 람다 사용
Runnable r1 = () -> System.out.println("Hello World 1");

// 익명 클래스 사용
Runnable r2 = new Runnable() {
    public void run() {
        System.out.println("Hello World 2");
    }
}

public static void process(Runnable r) {
    r.run();
}

process(r1);	// 'Hello World 1' 출력
process(r2);	// 'Hello World 2' 출력
process(() -> System.out.println("Hello World 3"));		// 'Hello World 3' 출력

/**
 * 1 단계 : 동작 파라미터화를 기억하라
 *  - 한 번에 한 줄만 읽을 수 있는 코드를 "동작 파라미터화"를 통해 다른 동작을 수행할 수 있도록 변경해 보자!
 *  - 즉, 아래 코드에서 "초기화 & 정리" 코드만 재사용하고 "처리" 코드는 동적으로 수행하도록 한다.
 */
public static String processFile() throws IOException {
    try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
        return br.readLine();	// 실제 필요한 작업을 수행
    }
}

/**
 * 2 단계 : 함수형 인터페이스를 이용해서 동작 전달
 *  - (BufferedReader -> String)과 IOException 예외를 던질 수 있는 시그니처와 일치하는 
 *    함수형 인터페이스를 만든다.
 */

public interface BufferedReaderProcessor {
    String process(BufferedReader b) throws IOException;
}
public static String processFile(BufferedReaderProcessor p) throws IOException {
    ...
}

/**
 * 3 단계 : 동작 실행!
 *   - 이제 BufferedReaderProcessor 함수형 인터페이스에 정의된 process 메서드의 
 *     시그니처(BufferedReader -> String)와 일치하는 람다를 전달할 수 있다.
 *   - 람다 표현식으로 함수형 인터페이스의 추상 메서드(process) 구현체를 직접 전달하여 처리할 수 있게 된다. 
 *     (4단계 참고)
 */
public static String processFile(BufferedReaderProcessor p) throws IOException {
    try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
        return p.process(br);
    }
}

/**
 * 4 단계 : 람다 전달
 */
String oneLine = processFile((BufferedReader br) -> br.readLine());
String twoLines = processFile((BufferedReader br) -> br.readLine() + br.readLine());

public interface Predicate<T> {
    boolean test(T t);
}

public static <T> List<T> filter(List<T> list, Predicate<T> p) {
    List<T> results = new ArrayList<>();
    for (T s: list) {
        if (p.test(s)) {
            results.add(s);
        }
    }
    return results;
}

Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();
List<String> nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);

public interface Consumer<T> {
    void accept(T t);
}

public static <T> void forEach(List<T> list, Consumer<T> c) {
    for (T i: list) {
        c.accept(i);
    }
}

forEach(Arrays.asList(1, 2, 3, 4, 5), (Integer i) -> System.out.println(i));

public interface Function<T, R> {
    R apply(T t);
}

public static <T, R> List<R> map(List<T> list, Function<T,R> f) {
    List<R> result = new ArrayList<>();
    for (T s : list) {
        result.add(f.apply(s));
    }
    return result;
}

// [7, 2, 6]
List<Integer> l = map(Arrays.asList("lambdas", "in", "action"), (String s) -> s.length());

// before
inventory.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));

// after
inventory.sort(comparing(Apple::getWeight));

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

// after
Supplier<Apple> c1 = Apple::new;
Apple a1 = c1.get();

/**
 * Integer 인수 1개를 갖는 생성자
 */
// before
Function<Integer, Apple> c2 = (weight) -> new Apple(weight);
Apple a2 = c2.apply(110);

// after
Function<Integer, Apple> c2 = Apple::new;
Apple a2 = c2.apply(110);

/**
 * String, Integer 인수 2개를 갖는 생성자
 */
// before
BiFunction<String, Integer, Apple> c3 = (color, weight) -> new Apple(color, weight);
Apple c3 = c3.apply("green", 110);

// after
BiFunction<String, Integer, Apple> c3 = Apple::new;
Apple c3 = c3.apply("green", 110);

// 1단계 : 동작 파라미터화를 통한 코드 전달
public class AppleComparator implements Comparator<Apple> {
    public int compare(Apple a1, Apple a2) {
        return a1.getWeight().compareTo(a2.getWeight());
    }
}
inventory.sort(new AppleComparator());

// 2단계 : 익명 클래스 사용
inventory.sort(new Comparator<Apple>() {
    public int compare(Apple a1, Apple a2) {
        return a1.getWeight().compareTo(a2.getWeight());
    }
});

// 3-1단계 : 람다 표현식 사용
inventory.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));
// 3-2단계 : 람다 표현식 코드 줄이기 (자바 컴파일러가 람다의 파라미터 형식을 추론)
inventory.sort((a1, a2) -> a1.getWeight().compareTo(a2.getWeight()));
// 3-3단계 : 정적 메서드 comparing 활용
import static java.util.Comparator.comparing;
inventory.sort(comparing((a) -> a.getWeight()));

// 4단계 : 메서드 레퍼런스 사용
import static java.util.Comparator.comparing;
inventory.sort(comparing(Apple::getWeight));