stream and lambda(3) - jdk 提供的函式式介面

@FunctionalInterface
public interface Function<T, R> {

    // 入參型別為T，處理後，返回型別為R的結果。
    R apply(T t);

    // 入參為 Function 物件 before，返回一個 Function 物件 result。
    // 執行時，先執行一次 before.apply 方法的，再執行 result.apply
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    // 入參為 Function 物件 after，返回一個 Function 物件 result。
    // 執行時，先執行一次 result.apply 方法的，再執行 after.apply
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    // 靜態方法，返回一個只會返回入參的 Function 物件。
    // 相當於 t->t 的簡寫，主要用於返回 lambda 表示式
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

public void doubleNum() {
    Function<Integer, String> d = integer -> String.valueOf(2 * integer);
    System.out.println(d.apply(10));
}

public void compose() {
    Function<Integer, String> d = integer -> {
        System.out.println("real double apply begins, param is " + integer);
        return String.valueOf(2 * integer);
    };
    //先將輸入的字串轉為Integer，再乘法。compose的入參可以指定，輸出一定要是apply的入參
    Function<String, String> compose = d.compose(s -> {
        System.out.println("compose begins, str to integer, str is " + s);
        return Integer.valueOf(s);
    });
    System.out.println("final result is " + compose.apply("10"));
}

public void andThen() {
    Function<Integer, String> d = integer -> {
        System.out.println("real double apply begins, param is " + integer);
        return String.valueOf(2 * integer);
    };

    //andThen傳入的是apply的結果，處理後的型別可以指定
    Function<Integer, String> andThen = d.andThen(s -> {
        System.out.println("and then begins");
        return "after and then, result is " + s;
    });

    System.out.println(andThen.apply(10));
}

public void identify() {
    List<Student> list = new ArrayList<>();
    list.add(new Student("1", "張三"));
    list.add(new Student("2", "李四"));

    //兩種寫法等效的
    Map<String, Student> map1 = list.stream().collect(Collectors.toMap(Student::getId, s -> s));
    Map<String, Student> map2 = list.stream().collect(Collectors.toMap(Student::getId, Function.identity()));
}

@FunctionalInterface
public interface Consumer<T> {
    //處理邏輯
    void accept(T t);

    //傳入一個後置函式
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

public static void main(String[] args) {
    Consumer<String> c1 = str -> System.out.println("this is the first time, word is " + str);
    Consumer<String> c2 = str -> System.out.println("this is the second time, word is " + str);
    List<String> stringList = Arrays.asList("I", "am", "the", "demo");

    stringList.forEach(c1);
    stringList.forEach(c1.andThen(c2));
}

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

public void demo() {
    Supplier<Double> random = Math::random;
    System.out.println(random.get());

    Supplier<String> s = String::new;
    String result = Stream.of("this", "is", "is", "a", "demo").findFirst().orElseGet(s);
    System.out.println(result);
}

@FunctionalInterface
public interface Predicate<T> {

    //業務判斷邏輯
    boolean test(T t);
    //and 邏輯
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    //取非邏輯
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
    //or 邏輯
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    //靜態方法，返回一個Predicate函式，用於判斷兩個物件是否相等
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

public static void demo() {
    Predicate<Integer> p1 = integer -> integer > 10;
    Predicate<Integer> p2 = integer -> integer < 5;

    System.out.println("7 > 10 :" + p1.test(7));
    System.out.println("7 !< 5 :" + p2.negate().test(7));
    System.out.println("7 > 10 && 7 < 5 : " + p1.and(p2).test(7));
    System.out.println("0 > 10 || 0 < 5 : " + p1.or(p2).test(0));
    System.out.println("null equals null : " + Predicate.isEqual(null).test(null));
}

public interface UnaryOperator<T> extends Function<T, T> {
    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

public void unaryDemo() {
    Function<Integer, Integer> squareFunc = integer -> integer * integer;
    UnaryOperator<Integer> squareUnary = integer -> integer * integer;

    System.out.println(squareFunc.apply(9));
    System.out.println(squareUnary.apply(9));
}

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {

    //根據比較器，返回較小的那個
    public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }

    //根據比較器，返回較大的那個
    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }
}

public void multiply() {
    BinaryOperator<Integer> multiply = (i1, i2) -> i1 * i2;
    System.out.println(multiply.apply(3, 5));
}

public void compare() {
    BinaryOperator<Integer> min = BinaryOperator.minBy(Comparator.comparingInt(i -> i));
    BinaryOperator<Integer> max = BinaryOperator.maxBy(Comparator.comparingInt(i -> i));
    System.out.println(min.apply(1,2));
    System.out.println(max.apply(1,2));
}