函數式接口

（一）、函數式接口的概念

函數式接口在Java中是指：有且僅有一個抽象方法的接口。
函數式接口，即适用于函數式程式設計場景的接口。而Java中的函數式程式設計展現就是Lambda，是以函數式接口就是可以适用于Lambda使用的接口。隻有確定接口中有且僅有一個抽象方法，Java中的Lambda才能順利地進行推導。
如何檢測一個接口是不是函數式接口呢？

①、
@FunctionalInterface ②、放在接口定義的上方：如果接口是函數式接口，編譯通過；如果不是，編譯失敗。

//定義一個函數式接口
@FunctionalInterface
public interface MyInterface {
    void show();
}

/*函數式接口：有且僅有一個抽象方法的接口*/
public class MyInterfaceDemo {
    public static void main(String[] args) {
        //函數式接口作為局部變量的時候，将Lambda表達式指派給它
        MyInterface my = () -> System.out.println("函數時接口");
        my.show();
    }
}

注意：我們自己定義函數式接口的時候，@FunctionalInterface是可選的，就算我不寫這個注解，隻要保證滿足函數式接口定義的條件，也照樣是函數式接口。但是，建議加上該注解。

（二）、函數式接口作為方法的參數

1. 需求

定義一個類 （RunnableDemo）
，在類中提供兩個方法

①、一個方法是：
startThread(Runnable r) 方法參數 Runnable
是一個函數式接口。

②、一個方法是主方法：在主方法中調用
startThread 方法。

public class RunnableDemo {
    public static void main(String[] args) {
        //匿名内部類的方式
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"線程啟動了...");
            }
        });

        //Lambda表達式的方式
        startThread(() -> System.out.println(Thread.currentThread().getName()+"線程啟動了..."));
    }

    //Runnable是一個函數式接口,作為參數
    private static void startThread(Runnable r){
		//Thread t = new Thread();
		//t.start();
        new Thread(r).start();
    }
}

運作結果：

Thread-0線程啟動了...
Thread-1線程啟動了...

如果方法的參數是一個函數式接口，我們可以使用Lambda表達式作為參數傳遞 startThread(() -> System.out.println(Thread.currentThread().getName()+"線程啟動了..."));

（三）、函數式接口作為方法的傳回值

1. 需求

定義一個類 （ComparatorDemo）
，在類中提供兩個方法

①、一個方法：
Comparator<String> getComparator() 方法傳回值 Compartor
是一個函數式接口

②、一個方法是主方法，在主方法中調用
getComparator 方法。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ComparatorDemo {
    public static void main(String[] args) {
        //構造使用場景

        //定義集合，存儲字元串元素
        ArrayList<String> array = new ArrayList<>();

        array.add("cccc");
        array.add("aa");
        array.add("b");
        array.add("ddd");

        System.out.println("排序前："+array);

        //Collections.sort(array);
        Collections.sort(array,getComparator());

        System.out.println("排序後："+array);
    }

    private static Comparator<String> getComparator() {
//        Comparator<String> comp = new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length() - s2.length();
//            }
//        };
//        return comp;

        //匿名内部類的方式實作
//        return new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length() - s2.length();
//            }
//        };

        //Lambda表達式的方式實作
//        return (String s1 ,String s2) -> {
//            return s1.length() - s2.length();
//        };

        return (s1 ,s2) ->s1.length() - s2.length();
    }
}

運作結果：

排序前：[cccc, aa, b, ddd]
排序後：[b, aa, ddd, cccc]

如果方法的傳回值是一個函數式接口，我們可以使用Lambda表達式作為結果傳回

private static Comparator<String> getComparator(){
	return (s1,s2) -> s1.length()-s2.length();
}

（四）、常用的函數式接口

Java 8在java.util.function包下預定義了大量的函數式接口供我們使用

1. Supplier接口

主要是用來生産資料的。
Supplier<T> ：包含一個無參的方法。
該方法不需要參數，它會按照某種實作邏輯（由Lambda表達式實作）傳回一個資料。
Supplier接口也被稱為生産型接口，如果我們指定了接口的泛型式什麼是類型，那麼接口的get方法就會生産什麼類型的資料供我們使用。

（1）簡答使用

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
//        String s = getString(() -> {
//            return "林青霞";
//        });

        //優化代碼
        String s = getString(() -> "林青霞");
        System.out.println(s);

        Integer i = getInteger(() -> 30);
        System.out.println(i);
    }

    //定一個方法，傳回一個整型資料
    private static Integer getInteger(Supplier<Integer> sup){
        return sup.get();
    }

    //定義一個方法，傳回一個字元串資料
    private static String getString(Supplier<String> sup){
        return sup.get();
    }
}

（2）練習

定義一個類（SupplierTest），在類中提供兩個方法

①、一個方法是：int getMax(Supplier< Integer > sup)用于傳回一個int數組得最大值。

②、一個方法是主方法，在主方法中調用getMax方法。

import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        //定義一個int數組
        int[] arr = {19,50,28,37,46};

        int maxValue = getMax(() -> {
            int max = arr[0];

            for (int i = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxValue);//50
    }

    //傳回一個int數組中的最大值
    private static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
}

2. Consumer接口

Consumer< T >：包含兩個方法。

①、
void accept(T t)
：對給定的參數執行此操作。

②、
default Consumer <T> andThen(Consumer after)
：傳回一個組合的Consumer，依次執行操作，然後執行after操作。

③、
Consumer<T> 接口也被稱為消費型接口，它消費的資料的資料類型由泛型指定

（1）簡單使用

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
//        operatorString("林青霞", (String s) -> {
//            System.out.println(s);//林青霞
//        });
        //優化代碼
        operatorString("林青霞",s -> System.out.println(s));//林青霞

//        operatorString("林青霞",s -> {
//            System.out.println(new StringBuilder(s).reverse().toString());//霞青林
//        });
        //優化代碼
        operatorString("林青霞",s -> System.out.println(new StringBuilder(s).reverse().toString()));//霞青林
    }

    //定義一個方法，消費一個字元串資料
    private static void operatorString(String name, Consumer<String> con){
        con.accept(name);
    }
}

import java.util.Comparator;
import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
        operatorString("林青霞",s -> System.out.println(s),s -> System.out.println(new StringBuilder(s).reverse().toString()));
    }


    //定義一個方法，消費一個字元串資料
    private static void operatorString(String name, Consumer<String> con1,Consumer<String> con2){
        //con1.accept(name);
        //con2.accept(name);
        //與上面效果一緻
        con1.andThen(con2).accept(name);
    }
}

（2）練習

String[] strArray = {"林青霞,30", "張曼玉,35", "王祖賢,33"};
字元串數組中有多條資訊，請按照格式：“姓名：XX,年齡：XX"的格式将資訊列印出來
要求：

①、把列印姓名的動作作為第一個Consumer接口的Lambda執行個體

②、把列印年齡的動作作為第二個Consumer接口的Lambda執行個體

③、将兩個Consumer接口按照順序組合到一起使用

import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "張曼玉,35", "王祖賢,33"};

//        printInfo(strArray,(String str) ->{
//            String name = str.split(",")[0];
//            System.out.print("姓名："+name);
//        },(String str) -> {
//            int age = Integer.parseInt(str.split(",")[1]);
//            System.out.println(",年齡："+age);
//        });

        //優化代碼
        printInfo(strArray, 
                str -> System.out.print("姓名：" + str.split(",")[0]),
                str -> System.out.println(",年齡：" + Integer.parseInt(str.split(",")[1]))
        );
    }

    private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
        for (String str : strArray) {
            con1.andThen(con2).accept(str);
        }
    }
}

運作結果

姓名：林青霞,年齡：30
姓名：張曼玉,年齡：35
姓名：王祖賢,年齡：33

3. Predicate接口

Predicate<T>
：常用的四個方法

①、
boolean test(T t) ：對給定的參數進行判斷(判斷邏輯由Lambda表達式實作)，傳回一個布爾值

import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
		//boolean b1 = checkString("hello", (String s) -> {
		//	return s.length() > 8;
		//});
        //代碼優化
        boolean b1 = checkString("hello",s -> s.length() > 8);
        System.out.println(b1);//false
        
        boolean b2 = checkString("hellowordl" ,s -> s.length() > 8);
        System.out.println(b2);//true
    }

    //判斷給定的字元串是否滿足要求
    private static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }
}

②、 default Predicate<T> negate()
：傳回一個邏輯的否定，對應邏輯非

通過替換return語句後再次運作代碼就可以看出，與上面運作的結果是相反的

//判斷給定的字元串是否滿足要求
private static boolean checkString(String s, Predicate<String> pre){
	//return pre.test(s);
	
	//上下兩個語句得到的結果相反
	
	//return !pre.test(s);
	return pre.negate().test(s);
}

③、 default Predicate<T> and(Predicate other) ：傳回一個組合判斷，對應短路與

import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
        boolean b3 = checkString("hello", s -> s.length()>8, s -> s.length()<15);
        System.out.println(b3);

        boolean b4 = checkString("helloworld", s -> s.length()>8, s -> s.length()<15);
        System.out.println(b4);
    }

    //同一個字元串給出兩個不同的判斷條件，最後把這個判斷的結果做邏輯與運算的結果作為最終的結果
    private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
		//boolean b1 = pre1.test(s);
		//boolean b2 = pre2.test(s);
		//boolean b = b1 && b2;
		//return b;

        //代碼優化
        return pre1.and(pre2).test(s);
    }
}

④、 default Predicate<T> or(Predicate other) ：傳回一個組合判斷，對應短路或

//同一個字元串給出兩個不同的判斷條件，最後把這個判斷的結果做邏輯與運算的結果作為最終的結果
private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
	//boolean b1 = pre1.test(s);
	//boolean b2 = pre2.test(s);
	//boolean b = b1 || b2;
	//return b;
	
	//代碼優化
	return pre1.or(pre2).test(s);
}

⑤、 Predicate<T> 接口通常用于判斷參數是否滿足指定的條件

4. 練習

String[] strArray = {"林青霞,30", "柳岩,34", "張曼玉,35", "貂蟬,31", "王祖賢,33"};
字元串數組中有多條資訊，請通過Predicate接口的拼裝将符合要求的字元串篩選到集合ArrayList中，并周遊ArrayList集合
同時滿足如下要求：姓名長度大于2；年齡大于33
分析

①、有兩個判斷條件,是以需要使用兩個Predicate接口,對條件進行判斷

②、必須同時滿足兩個條件,是以可以使用and方法連接配接兩個判斷條件

import java.util.ArrayList;
import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "柳岩,34", "張曼玉,35", "貂蟬,31", "王祖賢,33"};
        ArrayList<String> array = myFilter(strArray,
                s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33
        );
        System.out.println(array);
    }

    //通過Predicate接口的拼裝将符合的字元串選到集合ArrayList中
    private static ArrayList<String> myFilter(String[] strArray,Predicate<String> pre1, Predicate<String> pre2){
        //定義一個集合
        ArrayList<String> array = new ArrayList<>();

        //周遊數組
        for (String str:strArray){
            if (pre1.and(pre2).test(str)){
                array.add(str);
            }
        }
        return array;
    }
}

4. Function接口

Function<T,R>
：常用的兩個方法

①、
R apply(T t) ：将此函數應用于給定的參數

import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
        // convert("100",(String s)->{
        //     return Integer.parseInt(s);
        // });

        //優化代碼
        //方法一：
        convert("100",s -> Integer.parseInt(s));
        //方法二：
        convert(100,i -> String.valueOf(i+566));
        //方法三：
        convert("100",s -> Integer.parseInt(s),
                i -> String.valueOf(i+566)
        );
    }

    //定義一個方法，把一個字元串轉換int類型，在控制台輸出
    private static void convert(String s, Function<String,Integer> fun){
        //Integer i = fun.apply(s);
        int i = fun.apply(s);
        System.out.println(i);
    }

    //定義一個方法，把一個int類型的資料加上一個整數之後，轉換為字元串在控制台輸出
    private static void convert(int i,Function<Integer,String> fun){
        String s = fun.apply(i);
        System.out.println(s);
    }

    //定義一個方法，把一個字元串轉換int類型，把int類型的資料加上一個整數之後，轉換為字元串在控制台輸出
    private static void convert(String s,Function<String,Integer> fun1,Function<Integer,String> fun2){
        Integer i = fun1.apply(s);
        String ss = fun2.apply(i);
        System.out.println(ss);
    }
}

②、

default <V> Function andThen(Function after)

：傳回一個組合函數，首先将該函數應用于輸入，然後将after函數應用于結果。

//定義一個方法，把一個字元串轉換int類型，把int類型的資料加上一個整數之後，轉換為字元串在控制台輸出
private static void convert(String s,Function<String,Integer> fun1,Function<Integer,String> fun2){
    //Integer i = fun1.apply(s);
    //String ss = fun2.apply(i);
    //System.out.println(ss);

	//上下代碼運作結果一緻

    String ss = fun1.andThen(fun2).apply(s);
    System.out.println(ss);
}

③、

Function<T,R>

接口通常用于對參數進行處理，轉換(處理邏輯由Lambda表達式實作)，然後傳回一個新的值

2. 練習

String s = "林青霞,30";
請按照我指定的要求進行操作：

①、将字元串截取得到數字年齡部分

②、将上一步的年齡字元串轉換成為int類型的資料

③、将上一步的int資料加70，得到一個int結果，在控制台輸出
請通過Function接口來實作函數拼接

import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        String s = "林青霞,30";

        //convert(s, (String ss) -> {
        //    return s.split(",")[1];
        //}, (String ss) -> {
        //    return Integer.parseInt(ss);
        //}, (Integer i) -> {
        //    return i+70;
        //});

        //代碼優化
        convert(s,
                ss-> ss.split(",")[1],
                ss->Integer.parseInt(ss),i->i+70
        );
    }

    private static void convert(String s, Function<String,String> fun1,Function<String,Integer> fun2,Function<Integer,Integer> fun3){
        //Integer i = fun1.andThen(fun2).andThen(fun3).apply(s);
        int i = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(i);
    }
}

函數式接口的相關概念以及常用的函數式接口（Supplier、Consumer、Predicate、Function）函數式接口

函數式接口

（一）、函數式接口的概念

（二）、函數式接口作為方法的參數

1. 需求

（三）、函數式接口作為方法的傳回值

1. 需求

（四）、常用的函數式接口

1. Supplier接口

（1）簡答使用

（2）練習

2. Consumer接口

（1）簡單使用

（2）練習

3. Predicate接口

4. 練習

4. Function接口

2. 練習

繼續閱讀

關于Flex及AS3的百多條小小知識

AS3 Signals之入門篇

Flash AS3 連續加載外部若幹圖檔

2.4和2.6核心的netfilter差異點

What are training set, validation set and test set?

java 程式設計思想第四版學習随記

ms sqlserver常用sql語句

java之單使用者登入

Java反射是什麼，為什麼要用反射

Double類parseDouble和valueOf方法的差別

java調用Windows指令行

java列印任意邊長的菱形

可變參數宏， Variadic Macros

不用iconv函數實作UTF-8編碼轉換GB2312的PHP函數

java 8 Lamda 求 List 中 Bigdecimal類型的各種值求最大值求最小值求和求平均值

無元件上傳圖檔到資料庫中，最完整解決方案