【java8新特性】02：常見的函數式介面

public class Main {

    /**
     * Consumer<T>
     *     消費型介面：顧名思義主要用於消費引數，不反饋呼叫環境（沒有返回值）
     *     accept: 抽象方法實現，用於呼叫方法。
     *     andThen： 預設實現方法，內部允許我們鏈式呼叫
     */
    public static void main(String[] args) {
        // 1.我們需要將集合進行排序後在輸出到控制檯
        Consumer<List> con1 = list-> {
            System.out.println("排序前的集合："+ list);
            Collections.sort(list);
            System.out.println("排序後的集合："+list);
        };
        con1.accept(Arrays.asList(1,5,3,2,9,6,7));
        /**
         * 最終結果：
         * 排序前的集合：[1, 5, 3, 2, 9, 6, 7]
         * 排序後的集合：[1, 2, 3, 5, 6, 7, 9]
         */
        // 上面執行邏輯實現分兩步，第一步需要獲取到給定集合進行排序，第二個則是輸出排序後的集合
        // 如果以上兩個步驟分別用兩個consumer也可以實現，我們可以定義一個方法接收兩個consumer進行操作
        accept(Arrays.asList(1,5,3,2,9,6,7),list->
        {
            System.out.println("andThen鏈式呼叫前集合："+list);
            Collections.sort(list);
        },list-> System.out.println("andThen鏈式呼叫後集合:"+ list));
        /**
         * 最終結果：
         * andThen鏈式呼叫前集合：[1, 5, 3, 2, 9, 6, 7]
         * andThen鏈式呼叫後集合:[1, 2, 3, 5, 6, 7, 9]
         */
        // 如果consumer引數多個的話，我們可以直接在Lambda表示式進行鏈式呼叫，不費那勁定義方法了
        Consumer<List> con2 = ((Consumer<List>) list -> {
            System.out.println("lambda表示式的鏈式呼叫前集合：" + list);
            Collections.sort(list);
        }).andThen(list -> System.out.println("lambda表示式的鏈式呼叫後集合："+list));
        // 需要注意的是：要使用這種方式，第一個consumer要進行鏈式呼叫必須要強行指定為(Consumer)型別，後續的介面才能夠呼叫方法
        con2.accept(Arrays.asList(1,53,31,25,99,62,17));
        /**
         * 最終結果：
         * lambda表示式的鏈式呼叫前集合：[1, 53, 31, 25, 99, 62, 17]
         * lambda表示式的鏈式呼叫後集合：[1, 17, 25, 31, 53, 62, 99]
         */
    }

    public static void accept(List<Integer> list,Consumer<List> con1,Consumer<List> con2){
        // 鏈式呼叫時會優先執行左邊的介面實現，依次往右執行 我們的需求是先排序後輸出，第一個Consumer是排序，第二個是輸出。
        con1.andThen(con2).accept(list);
    }
}

public class Main{

    /**
     *  Function<T,R>函數型的函數式介面，泛型T是引數、泛型R則是返回值、主要應用場景做資料型別轉換等。
     *  R apply(T t): 抽象方法實現，用於呼叫方法並返回泛型R
     *  <V> Function<T, V> andThen： 預設實現方法，內部允許我們鏈式呼叫，與其他的andThen原理一致。
     *  <V> Function<V, R> compose： 預設實現方法，內部允許我們鏈式呼叫，呼叫方式與andThen一樣，但執行順序不一樣，compose是先執行compose中的函數介面，再執行左邊呼叫的函數介面，依次往左
     *  <T> Function<T, T> identity()：返回當前執行的方法，從原始碼中我們也可以看到它返回的是當前的t
     */
    public static void main(String[] args) {

        // 傳入給定字串，返回轉換後的Integer型別
        Function<String,Integer> fun1 = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                Integer convert = Integer.valueOf(s);
                System.out.println("通過匿名內部類的方式獲取到的值："+ convert +"，資料型別是否為Integer？結果：" + (convert instanceof Integer));
                return convert;
            }
        };
        // 執行該方法的時候，它會去執行我們上述實現的apply方法。
        fun1.apply("10086");
        // 通過lambda表示式的方式進行實現
        Function<String,Integer> fun2 = s->{
            Integer convert = Integer.valueOf(s);
            System.out.println("通過lambda表示式的方式獲取到的值："+ convert +"，資料型別是否為Integer？結果：" + (convert instanceof Integer));
            return convert;
        };
        fun2.apply("10000");
        /**
         * 通過匿名內部類的方式獲取到的值：10086，資料型別是否為Integer？結果：true
         * 通過lambda表示式的方式獲取到的值：10000，資料型別是否為Integer？結果：true
         * 使用lambda表示式，我們只需要記住參數列和執行邏輯即可，其他的我們無需關注。
         */
        // 我們繼續對Function的API做一些理解和補充，畢竟這玩意在工作中經常會用上
        // andThen 我們都知道常用於鏈式呼叫的，這裡必須保證T和V型別是一樣的，也就是引數泛型T和返回值泛型V
        Function<String,String> fun3 = x-> {
            System.out.println("我是fun3的方法");
            return x;
        };
        Function<String,String> fun4 = y-> {
            System.out.println("我是fun4的方法");
            return y;
        };
        fun3.andThen(fun4).apply("test");
        /**
         * 最終結果：
         * 我是fun3的方法
         * 我是fun4的方法
         */
        // 我們發現這裡是先執行fun3的apply方法再執行fun4的apply方法的。
        // compose 與andThen一樣都是鏈式呼叫，但結果卻大大不同，這裡必須保證T和V型別是一樣的，也就是引數泛型T和返回值泛型V
        fun3.compose(fun4).apply("test");
        /**
         * 最終結果：
         * 我是fun4的方法
         * 我是fun3的方法
         */
        // 我們發現這裡是先執行的fun4的apply方法再執行fun3的apply方法的
        // 由此我們推斷出compose和andThen的區別就在於，compose介面方法執行順序從右到左，而andThen則是從左到右。
        Function<Object, Object> identity = Function.identity();
        // Function.identity() 靜態方法這裡就不好演示了，這個通常在後面搭配Stream流轉Map型別的時候用到，它返回本身
    }
}

public class Main{

    /**
     *  Function<T,R>函數型的函數式介面，泛型T是引數、泛型R則是返回值、主要應用場景做資料型別轉換等。
     *  R apply(T t): 抽象方法實現，用於呼叫方法並返回泛型R
     *  <V> Function<T, V> andThen： 預設實現方法，內部允許我們鏈式呼叫，與其他的andThen原理一致。
     *  <V> Function<V, R> compose： 預設實現方法，內部允許我們鏈式呼叫，呼叫方式與andThen一樣，但執行順序不一樣，compose是先執行compose中的函數介面，再執行左邊呼叫的函數介面，依次往左
     *  <T> Function<T, T> identity()：返回當前執行的方法，從原始碼中我們也可以看到它返回的是當前的t
     */
    public static void main(String[] args) {
        List<Person> persons = Arrays.asList(new Person(1,"張三"),new Person(2,"李四"));
        // 給定一個person物件集、轉換成姓名屬性集合返回
        Function<List<Person>,List<String>> fun1 = list-> {
            List<String> arr = new ArrayList<>();
            for (int i = 0;  i < list.size(); i++) {
                arr.add(list.get(i).getName());
            }
            return arr;
        };
        List<String> personNames = fun1.apply(persons);
        System.out.println(personNames);
        /**
         * 最終結果：
         * 結果：[張三, 李四]
         */
    }
}

class Person{
    private Integer id;
    private String name;

    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }


    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

public class Main{

    /**
     *  Predicate<T>斷言型的函數式介面，泛型T是引數、返回結果型別為布林型別的函數介面。
     *  boolean test(T t): 抽象方法實現，用於返回傳入的引數邏輯運算後布林型別結果
     *  Predicate<T> and： 預設實現方法，內部允許我們鏈式呼叫，用於同時判定多個Predicate函數介面的實現 類似於邏輯運算中的短路&操作。
     *  Predicate<T> negate： 預設實現方法，內部允許我們鏈式呼叫，用於同時判定多個Predicate函數介面的實現，用於將當前判定結果取反後返回，類似於邏輯運算中的!操作
     *  Predicate<T> or：預設實現方法，內部允許我們鏈式呼叫，用於同時判定多個Predicate函數介面的實現 類似於邏輯運算中的||操作。
     *  Predicate<T> isEqual：靜態方法，內部允許我們鏈式呼叫，在保證引數不是空的情況下它內部實現邏輯實際上呼叫的是Object的equals，具體equals看子類有沒有重寫
     */
    public static void main(String[] args) {
        // 判斷給定字串是否純數位並且小於10 可以使用and進行鏈式呼叫
        Predicate<String> pre1 = ((Predicate<String>) s -> s.matches("[0-9]{1,}")).and(x->Integer.valueOf(x) <10);
        System.out.println("使用and方式進行鏈式呼叫："+pre1.test("9"));
        // 需要注意的是：要使用這種方式，第一個Predicate要進行鏈式呼叫必須要強行再指定為(Predicate)型別，後續的介面才能夠呼叫方法
        // 實際上這種方式用的比較少，因為比較麻煩，所以一般都會直接使用&&進行判定
        Predicate<String> pre2 = s->  s.matches("[0-9]{1,}") && Integer.valueOf(s) <10;
        System.out.println("使用&&方式呼叫:"+pre2.test("10"));
        /**
         * 最終結果：
         * 使用and方式進行鏈式呼叫：true
         * 使用&&方式呼叫:false
         */
    }
}