package java.util.function;

import java.util.Objects;

/**
 *
 * @param <T> 輸入?yún)?shù)類型
 * @param
@FunctionalInterface
public interface Function<T, R> {

    /**
    抽象方法：輸入T類型參數(shù)，返回R類型的值
    T和R是泛型哦，小伙伴不要搞混
     */
    R apply(T t);

    /**
     JDK8新特性，接口中可以存在默認實現(xiàn)
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before){
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
    默認實現(xiàn)
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after){
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
    JDK8接口新特性：可以有靜態(tài)方法
     */
    static <T> Function<T, T> identity(){
        return t -> t;
    }
}

public class FunctionMain {
    public static void main(String[] args) {

        // 1、原始匿名內(nèi)部類寫法
        Function<String, String> function1 = new Function<String, String>() {
            @Override
            public String apply(String inputStr) {
                // 轉(zhuǎn)換為大寫
                return inputStr.toUpperCase();
            }
        };

        String result = function1.apply("Just give me a chance to start!");
        System.out.println(result);

        // 2、Lambda表達式寫法
        Function<String,String> function2 = inputStr -> inputStr.toUpperCase();
        String lambdaResult = function2.apply("Lambda really smells good!");
        System.out.println(lambdaResult);

    }
}

package java.util.function;

import java.util.Objects;


@FunctionalInterface
public interface Predicate<T> {

    /**
     根據(jù)參數(shù)輸入判斷是否正確，返回true或者false
     */
    boolean test(T t);


    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);
    }

    default Predicate<T> or(Predicate<? super T> other){
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    
    static <T> Predicate<T> isEqual(Object targetRef){
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

public class PredicateMain {
    public static void main(String[] args){

        // 1、原始實現(xiàn)方式
        Predicate predicate1 = new Predicate<Integer>() {
            @Override
            public boolean test(Integer num){
                return num > 0;
            }
        };
        // 調(diào)用test方法
        boolean result = predicate1.test(1024);
        System.out.println(result);

        // 2、Lambda表達式實現(xiàn)
        Predicate<Integer> predicate2 = num -> num > 0;
        // 調(diào)用test方法
        boolean lambdaResult = predicate2.test(-1024);
        System.out.println(lambdaResult);

    }
}

package com.stt.function.myfunction;

/**
 * 自定義函數(shù)式接口：
 * 定義：
 *  1、接口中只有一個抽象方法
 *  2、可以使用@FunctionInterface注釋修飾，也可以不使用
 *      如果使用該注解報錯，說明該接口不是一個函數(shù)式接口
 */
@FunctionalInterface
public interface SttFunction<T,R,V> {

    /**
     * 接收兩個參數(shù)，并返回一個參數(shù)
     * 注意：接口嘛，定義個大概就行了，具體什么參數(shù)，怎么返回就不需要說明了，具體實現(xiàn)的時候再說唄
     */
    V calc(T t,R r);

}

package com.stt.function.myfunction;

public class SttFunctionMain {

    public static void main(String[] args) {
        // 1、原始方式，匿名內(nèi)部類實現(xiàn)
        SttFunction<Integer, Integer, Integer> sttFunction1 = new SttFunction<Integer, Integer, Integer>() {
            @Override
            public Integer calc(Integer num1, Integer num2) {
                return num1 * num2;
            }
        };
        Integer result = sttFunction1.calc(2, 2);
        System.out.println(result);

        // 2、Lambda表達式調(diào)用
        SttFunction<Integer,Integer,Integer> sttFunction = (num1,num2) -> num1 + num2;;

        Integer lambdaResult = sttFunction.calc(1023, 1);

        System.out.println(lambdaResult);

    }
}

package com.stt.function.myfunction;

/**
 * 自定義函數(shù)式接口：
 * 定義：
 *  1、接口中只有一個抽象方法
 *  2、可以使用@FunctionInterface注釋修飾，也可以不使用
 *      如果使用該注解報錯，說明該接口不是一個函數(shù)式接口
 */
@FunctionalInterface
public interface SttFunction<T,R,V> {

    /**
     * 接收兩個參數(shù)，并返回一個參數(shù)
     * 注意：接口嘛，定義個大概就行了，具體什么參數(shù)，怎么返回就不需要說明了，具體實現(xiàn)的時候再說唄
     */
    V calc(T t,R r);
    
    default void defaultMethod(){
        System.out.println("也不知道實現(xiàn)點什么，反正JDK8之后可以有默認實現(xiàn)！");
    }
    
    static void staticMethod(){
        System.out.println("同樣不知道寫點什么，反正JDK8之后可以有靜態(tài)方法！");
    }
}