RxJava - 함수형 메서드 레퍼런스

import java.util.function.Function;

/**
 * Class Name::static method 메서드 레퍼런스 예
 */
public class ClassNameStaticMethodExample {
    public static void main(String[] args) {
        // 람다 표현식 메서드 레퍼런스로 축약 전
        Function<String, Integer> f1 = (String s) -> Integer.parseInt(s);
        Integer result1 = f1.apply("3");
        System.out.println(result1);

        // 람다 표현식 메서드 레퍼런스로 축약 전
        Function<String, Integer> f2 = s -> Integer.parseInt(s);
        Integer result2 = f2.apply("3");
        System.out.println(result2);

        // 람다 표현식을 메서드 레퍼런스로 축약
        Function<String, Integer> f3 = Integer::parseInt;
        Integer result3 = f3.apply("3");
        System.out.println(result3);

    }
}

import com.itvillage.common.Car;

import java.util.function.Function;

public class ClassNameInstanceMethodExample {
    public static void main(String[] args) {
        Function<Car, String> f1 = car -> car.getCarName();
        String carName1 = f1.apply(new Car("트래버스"));
        System.out.println(carName1);

        Function<Car, String> f2 = Car::getCarName;
        String carName2 = f2.apply(new Car("팰리세이드"));
        System.out.println(carName2);
    }
}
/*
트래버스
팰리세이드
*/

/**
 * Object::instance method 예
 */
public class ObjectInstanceMethodExample {
    public static void main(String[] args) {
        final CarInventory carInventory = new CarInventory(10);

        Function<Integer, Integer> f1 = count -> carInventory.getExpectedTotalCount(count);
        int totalCount1 = f1.apply(10);
        System.out.println(totalCount1);

        Function<Integer, Integer> f2 = carInventory::getExpectedTotalCount;
        int totalCount2 = f2.apply(20);
        System.out.println(totalCount2);

        // T -> T
        UnaryOperator<Integer> f3 = carInventory::getExpectedTotalCount;
        int totalCount3 = f3.apply(30);
        System.out.println(totalCount3);

        // Integer -> Integer
        IntUnaryOperator f4 = carInventory::getExpectedTotalCount;
        int totalCount4 = f4.applyAsInt(40);
        System.out.println(totalCount4);
    }
}
/*
20
30
40
50
*/

/**
 * Constructor::new 예
 */
public class ConstructorReferenceExample {
    public static void main(String[] args) {
        Function<String, Car> f1 = s -> new Car(s);
        Car car1 = f1.apply("콜로라도");
        System.out.println(car1.getCarName());

        Function<String, Car> f2 = Car::new;
        Car car2 = f2.apply("카니발");
        System.out.println(car2.getCarName());
    }
}
/*
콜로라도
카니발
*/

public class QuizAnswerForChapter0402 {
    public static void main(String[] args) {
        Predicate<String> p = s -> s.isEmpty();
        Predicate<String> p1 = String::isEmpty;
        System.out.println("문제 1번 결과: " + p1.test("Not Empty"));

        Function<Integer, String> f = i -> String.valueOf(i);
        Function<Integer, String> f1 = String::valueOf;
        System.out.println("문제 2번 결과: " + f1.apply(3));


        BiPredicate<List<Integer>, Integer> q = (list, num) -> list.contains(num);
        BiPredicate<List<Integer>, Integer> q1 = List::contains;
        System.out.println("문제 3번 결과: " + q1.test(Arrays.asList(1, 3, 5, 7, 9), 9));

        Consumer<String> c = s -> System.out.println(s);
        Consumer<String> c1 = System.out::println;
        c1.accept("문제 4번 결과: Hello!");

        BiFunction<String, CarType, Car> t = (s1, s2) -> new Car(s1, s2);
        BiFunction<String, CarType, Car> t1 = Car::new;
        Car car = t1.apply("말리부", CarType.SEDAN);
        System.out.println("문제 5번 결과: " + car.getCarName() + " / " + car.getCarType());
    }
}
/*
문제 1번 결과: false
문제 2번 결과: 3
문제 3번 결과: true
문제 4번 결과: Hello!
문제 5번 결과: 말리부 / SEDAN
*/