目錄
1、函數式接口概述
有且僅有一個抽象方法的接口，通過在類上標注 @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類是一個函數式接口
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 包下預定義了大量的函數式接口供我們使用，以下為四大核心函數式接口
| 接口 | 說明 |
|---|---|
| Supplier
|
生產型接口，接口中泛型指定什么類型，則 get 方法就生產該類型數據，T - 出參類型，沒有入參 |
| Consumer
|
消費型接口，消費的數據其類型由泛型指定，T - 入參類型，沒有出參 |
| Predicate
|
斷言式接口，通常用於判斷參數是否滿足指定的條件，T - 入參類型，出參為 boolean 類型 |
| Function<T,R> | 函數式接口，通常用於對參數進行處理、轉換（處理邏輯由 Lambda 表達式實現），然后返回一個新的值，T - 入參類型，R - 出參類型 |
4.1、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
4.2、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
4.3、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
// 方法2
boolean b3 = checkString2("hello", s -> s.length() > 6); // true
boolean b4 = checkString2("hello", s -> s.length() < 6); // false
// 方法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
// 方法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
}
// 方法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
4.4、Function 接口
| 方法 | 說明 |
|---|---|
| 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