函數式接口
目錄
1、函數式接口概述
函數式接口： 有且僅有一個抽象方法的接口
Java 中的函數式編程體現就是 Lambda 表達式，所以函數式接口就是可以適用於 Lambda 使用的接口，只有確保接口中有且僅有一個抽象方法，Java 中的 Lambda 才能順利地進行推導。
如何檢測一個接口是不是函數式接口：@FunctionalInterface 註解放在接口定義的上方，如果接口是函數式接口編譯通過，如果不是編譯失敗。
注意： 自定義函數式接口時，@FunctionalInterface 是可選的，只要保證滿足函數式接口定義的條件，也照樣是函數式接口。但是建議加上該註解（規範）。
示例
@FunctionalInterface
public interface MyFunctionalInterface {
void show();
}
2、函數式接口作為方法的參數
示例
public class Test_01 {
public static void main(String[] args) {
// 匿名內部類方式
startRunable(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 線程啟動");
}
});
// lambda方式
startRunable(() -> System.out.println(Thread.currentThread().getName() + " 線程啟動"));
}
// Runnable類是一個函數s接口
public static void startRunable(Runnable r) {
new Thread(r).start();
}
}
Thread-0 線程啟動
Thread-1 線程啟動
3、函數式接口作為方法的返回值
示例： 按照字符串長度正序排序
public class Test_02 {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
list1.add("bbb");
list1.add("a");
list1.add("cc");
System.out.println("排序前 = " + list1);
Collections.sort(list1);
System.out.println("默認排序後 = " + list1);
ArrayList<String> list2 = new ArrayList<>();
list2.add("bbb");
list2.add("a");
list2.add("cc");
System.out.println("排序前 = " + list2);
Collections.sort(list2, getComparator());
System.out.println("自定義排序後 = " + list2);
}
// 按照字符串長度正序排序，將Comparator函數式接口作為返回值
// lambda方式
public static Comparator<String> getComparator() {
return (s1, s2) -> s1.length() - s2.length();
}
// 方法引用方式
public static Comparator<String> getComparator2() {
return Comparator.comparingInt(String::length);
}
// 匿名內部類方式
public static Comparator<String> getComparator3() {
return new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.length() - s2.length();
}
};
}
}
排序前 = [bbb, a, cc]
默認排序後 = [a, bbb, cc]
排序前 = [bbb, a, cc]
自定義排序後 = [a, cc, bbb]
4、常用函數式接口
Java 8 在 java.util.function 包下預定義了大量的函數式接口供我們使用
4.1、Supplier 接口
Supplier
| 方法 | 說明 |
|---|---|
| T get() | 該方法不需要參數，它會按照某種實現邏輯（由 Lambda 表達式實現）返回一個數據 |
示例
public class Test_03 {
public static void main(String[] args) {
String name = getString(() -> "勛悟空");
System.out.println("name = " + name);
Integer age = getInteger(() -> 500);
System.out.println("age = " + age);
}
// 返回 String 類型數據
public static String getString(Supplier<String> sup) {
return sup.get();
}
// 返回 Integer 類型數據
public static Integer getInteger(Supplier<Integer> sup) {
return sup.get();
}
// 返回其它類型數據...
}
name = 勛悟空
age = 500
練習： 獲取 int 數組最大值
public class Test_04 {
public static void main(String[] args) {
int arr[] = {5, 10, 7, 9, 8};
int maxValue = getMax(() -> {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
return max;
});
System.out.println("maxValue = " + maxValue);
}
public static int getMax(Supplier<Integer> sup) {
return sup.get();
}
}
10
4.2、Consumer 接口
Consumer
| 方法 | 說明 |
|---|---|
| void accept(T t) | 對給定的參數執行此操作 |
| default Consumer |
依次執行此操作，然後執行 after 操作 |
示例
public class Test_05 {
public static void main(String[] args) {
// 打印該字符串，消費了一次
operatorString("勛悟空", System.out::println);
// 先打印該字符串，再獲取該字符串的長度，消費了兩次
operatorString("勛悟空", System.out::println, s -> System.out.println(s.length()));
}
// 方法1：消費一個字符串數據
public static void operatorString(String name, Consumer<String> con) {
con.accept(name);
}
// 方法2：對一個字符串數據連續消費兩次
public static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
// con1.accept(name);
// con2.accept(name);
// 寫法優化
con1.andThen(con2).accept(name);
}
}
勛悟空
勛悟空
3
練習
-
題目
-
String[] strArray = {“林青霞,30”, “張曼玉,35”, “王祖賢,33”};
-
字符串數組中有多條信息，請按照格式：「姓名：XX,年齡：XX”的格式將信息打印出來
-
-
要求
-
把打印姓名的動作作為第一個 Consumer 接口的 Lambda 實例
-
把打印年齡的動作作為第二個 Consumer 接口的 Lambda 實例
-
將兩個 Consumer 接口按照順序組合到一起使用
-
public class Test_06 {
public static void main(String[] args) {
String[] strArray = {"林青霞,30", "張曼玉,35", "王祖賢,33"};
printInfo(strArray,
str -> System.out.print("姓名：" + str.split(",")[0]),
str -> System.out.println("，年齡：" + str.split(",")[1]));
}
public static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
for (String s : strArray) {
con1.andThen(con2).accept(s);
}
}
}
姓名：林青霞，年齡：30
姓名：張曼玉，年齡：35
姓名：王祖賢，年齡：33
4.3、Predicate 接口
Predicate
| 方法 | 說明 |
|---|---|
| boolean test(T t) | 對給定的參數進行判斷（判斷邏輯由 Lambda 表達式實現），返回一個布爾值 |
| default Predicate |
返回一個邏輯的否定，對應 邏輯非（ ! ） |
| default Predicate |
返回一個組合判斷，對應 短路與（&&） |
| default Predicate |
返回一個組合判斷，對應 短路或（||） |
示例
public class Test_07 {
public static void main(String[] args) {
// 方法1
boolean b1 = checkString1("hello", s -> s.length() > 6); // false
boolean b2 = checkString1("hello", s -> s.length() < 6); // true
System.out.println("b1 = " + b1);
System.out.println("b2 = " + b2);
System.out.println("--------");
// 方法2
boolean b3 = checkString2("hello", s -> s.length() > 6); // true
boolean b4 = checkString2("hello", s -> s.length() < 6); // false
System.out.println("b3 = " + b3);
System.out.println("b4 = " + b4);
System.out.println("--------");
// 方法3
boolean b5 = checkString3("hello", s -> s.length() > 6, s -> s.length() < 6); // false
boolean b6 = checkString3("hello", s -> s.length() > 3, s -> s.length() < 6); // true
System.out.println("b5 = " + b5);
System.out.println("b6 = " + b6);
System.out.println("--------");
// 方法4
boolean b7 = checkString4("hello", s -> s.length() > 6, s -> s.length() < 6); // true
boolean b8 = checkString4("hello", s -> s.length() > 3, s -> s.length() < 6); // true
System.out.println("b7 = " + b7);
System.out.println("b8 = " + b8);
}
// 方法1：判斷給定字符串是否滿足要求
public static boolean checkString1(String s, Predicate<String> pre) {
return pre.test(s);
}
// 方法2：判斷給定字符串是否滿足要求（結果取反）
public static boolean checkString2(String s, Predicate<String> pre) {
return pre.negate().test(s);
}
// 方法3：對同一個字符串給出兩個不同的判斷條件，再把這兩個結果做 短路與 運算，得出的結果做最終結果
public static boolean checkString3(String s, Predicate<String> pre1, Predicate<String> pre2) {
return pre1.and(pre2).test(s);
}
// 方法4：對同一個字符串給出兩個不同的判斷條件，再把這兩個結果做 短路或 運算，得出的結果做最終結果
public static boolean checkString4(String s, Predicate<String> pre1, Predicate<String> pre2) {
return pre1.or(pre2).test(s);
}
}
b1 = false
b2 = true
--------
b3 = true
b4 = false
--------
b5 = false
b6 = true
--------
b7 = true
b8 = true
練習
-
題目
-
String[] strArray = {“林青霞,30”, “西施,34”, “張曼玉,35”, “貂蟬,31”, “王祖賢,33”};
-
字符串數組中有多條信息，請通過 Predicate 接口的拼裝將符合要求的字符串篩選到集合 ArrayList 中，並遍歷 ArrayList 集合
-
同時滿足如下要求：姓名長度大於2，年齡大於33
-
-
分析
- 有兩個判斷條件，所以需要使用兩個 Predicate 接口對條件進行判斷
- 必須同時滿足兩個條件，所以可以使用 and 方法連接兩個判斷條件
public class Test_08 {
public static void main(String[] args) {
String[] strArray = {"林青霞,30", "柳岩,34", "張曼玉,35", "貂蟬,31", "王祖賢,33"};
ArrayList<String> arrayList = filterData(strArray,
s -> s.split(",")[0].length() > 2,
s -> Integer.parseInt(s.split(",")[1]) > 33);
for (String s : arrayList) {
System.out.println("s = " + s);
}
}
public static ArrayList<String> filterData(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
ArrayList<String> arrayList = new ArrayList<>();
for (String s : strArray) {
if (pre1.and(pre2).test(s)) {
arrayList.add(s);
}
}
return arrayList;
}
}
s = 張曼玉,35
4.4、Function 接口
Function<T,R> 接口通常用於對參數進行處理，轉換（處理邏輯由 Lambda 表達式實現），然後返回一個新的值，T – 入參類型，R – 出參類型
| 方法 | 說明 |
|---|---|
| R apply(T t) | 將此函數應用於給定的參數 |
| default |
返回一個組合函數，首先將該函數應用於輸入，然後將 after 函數應用於結果 |
示例
public class Test_09 {
public static void main(String[] args) {
// 方法1
convert("1", Integer::parseInt);
// 方法2
convert(1, i -> String.valueOf(i + 10));
// 方法3
convert("1", Integer::valueOf, s -> String.valueOf(s + 100));
}
// 方法1：將一個字符串轉換為Integer類型並在控制台輸出
public static void convert(String s, Function<String, Integer> fun) {
Integer i = fun.apply(s);
System.out.println("i = " + i);
}
// 方法2：將一個Integer類型數據加上一個整數之後，轉換為字符串並在控制台輸出
public static void convert(int i, Function<Integer, String> fun) {
String s = fun.apply(i);
System.out.println("s = " + s);
}
// 方法3：將一個字符串轉換為Integer類型，把Integer類型數據加上一個整數之後，再轉為字符串並在控制台輸出
public static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
String ss = fun1.andThen(fun2).apply(s);
System.out.println("ss = " + ss);
}
}
i = 1
s = 11
ss = 101
練習
-
題目
- String s = “勛悟空,500”;
-
要求
-
將字符串截取得到數字年齡部分
-
將上一步的年齡字符串轉換成為 Integer 類型數據
-
將上一步的 Integer 數據加 23，得到一個 Integer 結果，在控制台輸出
-
請通過 Function 接口來實現函數拼接
-
public class Test_10 {
public static void main(String[] args) {
String monkey = "勛悟空,500";
convert(monkey,
s -> monkey.split(",")[1], // 將字符串截取得到數字年齡部分
Integer::valueOf, // 將上一步的年齡字符串轉換成為Integer類型數據
s -> s + 23); // 將上一步的Integer數據加70，得到一個Integer結果
}
public 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);
System.out.println("i = " + i);
}
}
i = 523
