Java基礎進階筆記 - Day12 - 第三章 常用函數式接口
- Java基礎進階筆記 - Day12 - 第三章 常用函數式接口
-
- 3.1 Supplier接口
- 3.2 練習：求數組元素最大值
- 3.3 Consumer接口
- 3.4 練習：格式化列印資訊
- 3.5 Predicate接口
- 3.6 練習：集合資訊篩選
- 3.7 Function接口
- 3.8 練習：自定義函數模型拼接
Java基礎進階筆記 - Day12 - 第三章 常用函數式接口
系統：Win10
JDK：1.8.0_121
IDE：IntelliJ IDEA 2017.3.7
JDK提供了大量常用的函數式接口以豐富Lambda的典型使用場景，它們主要在 java.util.function 包中被提供。下面是最簡單的幾個接口及使用示例。
3.1 Supplier接口
java.util.function.Supplier<T> 接口僅包含一個無參的方法： T get()。用來擷取一個泛型參數指定類型的對象資料。由于這是一個函數式接口，這也就意味着對應的Lambda表達式需要“對外提供”一個符合泛型類型的對象資料
public class Demo01 {
private static String getString(Supplier<String> sup){
return sup.get();
}
public static void main(String[] args) {
String str1 = "Hello";
String str2 = "World";
System.out.println(getString(()->str1+str2));
}
}
3.2 練習：求數組元素最大值
題目
使用 Supplier 接口作為方法參數類型，通過Lambda表達式求出int數組中的最大值。提示：接口的泛型請使用 java.lang.Integer 類。
解答
public class Demo02 {
// 定義一個方法，方法的參數傳遞Supplier，泛型使用Integer
private static Integer getMax(Supplier<Integer> sup) {
return sup.get();
}
public static void main(String[] args) {
int[] arr = {6, 3, 96, 56, 84, 75, 26, 13};
// 調用getMax方法，參數傳遞Lambda
int max = getMax(() -> {
// 計算數組的最大值
int m = arr[0];
for (int i : arr) {
if (i > m) {
m = i;
}
}
return m;
});
System.out.println(max);
}
}
3.3 Consumer接口
java.util.function.Consumer<T> 接口則正好與Supplier接口相反，它不是生産一個資料，而是消費一個資料，其資料類型由泛型決定。
抽象方法：accept
Consumer 接口中包含抽象方法 void accept(T t)，意為消費一個指定泛型的資料。基本使用如：
public class Demo03 {
private static void consumeString(Consumer<String> consumer) {
consumer.accept("Hello");
}
public static void main(String[] args) {
consumeString(s -> System.out.println(s));
}
}
當然，更好的寫法是使用方法引用。
預設方法：andThen
如果一個方法的參數和傳回值全都是 Consumer 類型，那麼就可以實作效果：消費資料的時候，首先做一個操作，然後再做一個操作，實作組合。而這個方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代碼：
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
備注： java.util.Objects 的 requireNonNull 靜态方法将會在參數為null時主動抛出 NullPointerException 異常。這省去了重複編寫if語句和抛出空指針異常的麻煩。
要想實作組合，需要兩個或多個Lambda表達式即可，而 andThen 的語義正是“一步接一步”操作。例如兩個步驟組合的情況：
public class Demo04 {
private static void consumeString(Consumer<String> c1, Consumer<String> c2) {
c1.andThen(c2).accept("Hello");
}
public static void main(String[] args) {
consumeString(
s -> System.out.println(s.toUpperCase(Locale.ROOT)),
s -> System.out.println(s.toLowerCase(Locale.ROOT)));
}
}
運作結果将會首先列印完全大寫的HELLO，然後列印完全小寫的hello。當然，通過鍊式寫法可以實作更多步驟的組合
3.4 練習：格式化列印資訊
題目
下面的字元串數組當中存有多條資訊，請按照格式“ 姓名：XX。性别：XX。 ”的格式将資訊列印出來。要求将列印姓名的動作作為第一個 Consumer 接口的Lambda執行個體，将列印性别的動作作為第二個 Consumer 接口的Lambda執行個體，将兩個 Consumer 接口按照順序“拼接”到一起。
解答
public class Demo05 {
public static void main(String[] args) {
String[] arr = {"張三,男", "李四,男", "小翠,女", "王二,男"};
consumeString(
s -> {
System.out.print("姓名:" +
s.substring(0, s.indexOf(",")));
},
s -> {
System.out.println(",性别:" +
s.substring(s.indexOf(",") + 1));
},
arr);
}
private static void consumeString(Consumer<String> c1,
Consumer<String> c2,
String[] arr) {
for (String s : arr) {
c1.andThen(c2).accept(s);
}
}
}
3.5 Predicate接口
有時候我們需要對某種類型的資料進行判斷，進而得到一個boolean值結果。這時可以使用 java.util.function.Predicate<T> 接口。
抽象方法：test
Predicate 接口中包含一個抽象方法： boolean test(T t)。用于條件判斷的場景：
public class Demo06 {
private static void method(Predicate<String> pre) {
boolean test = pre.test("HelloWorld");
System.out.println("該字元串是否很長：" + test);
}
public static void main(String[] args) {
method(s -> {
return s.length() > 6;
});
}
}
條件判斷的标準是傳入的Lambda表達式邏輯，隻要字元串長度大于6則認為很長
預設方法：and
既然是條件判斷，就會存在與、或、非三種常見的邏輯關系。其中将兩個 Predicate 條件使用“與”邏輯連接配接起來實作“并且”的效果時，可以使用default方法 and 。其JDK源碼為：
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
如果要判斷一個字元串既要包含大寫“H”，又要包含大寫“W”，那麼：
public class Demo07 {
private static void method(Predicate<String> pre1, Predicate<String> pre2) {
boolean test = pre1.and(pre2).test("HelloWorld");
System.out.println("該字元串是否滿足要求：" + test);
}
public static void main(String[] args) {
method(s -> {
return s.contains("H");
}, s -> {
return s.contains("W");
});
}
}
預設方法：or
與 and 的“與”類似，預設方法 or 實作邏輯關系中的“或”。JDK源碼為：
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
如果希望實作邏輯“字元串包含大寫H或者包含大寫W”，那麼代碼隻需要将“and”修改為“or”名稱即可，其他都不變：
public class Demo08 {
private static void method(Predicate<String> pre1, Predicate<String> pre2) {
boolean test = pre1.or(pre2).test("hello world");
System.out.println("該字元串是否滿足要求：" + test);
}
public static void main(String[] args) {
method(s -> s.contains("H"), s -> s.contains("W"));
}
}
預設方法：negate
“與”、“或”已經了解了，剩下的“非”（取反）也會簡單。預設方法 negate 的JDK源代碼為：
default Predicate<T> negate() {
return (t) -> !test(t);
}
從實作中很容易看出，它是執行了test方法之後，對結果boolean值進行“!”取反而已。一定要在 test 方法調用之前調用 negate 方法，正如 and 和 or 方法一樣：
public class Demo09 {
private static void method(Predicate<String> pre) {
boolean test = pre.negate().test("HelloWorld");
System.out.println("字元串長度是否大于3:" + test);
}
public static void main(String[] args) {
method(s->s.length()>3);
}
}
3.6 練習：集合資訊篩選
題目
數組當中有多條“姓名+性别”的資訊如下，請通過 Predicate 接口的拼裝将符合要求的字元串篩選到集合 ArrayList 中，需要同時滿足兩個條件：
- 必須為女生
- 姓名為4個字
解答
public class Demo10 {
private static List<String> getList(Predicate<String> pre1,
Predicate<String> pre2,String[] arr){
List<String> list = new ArrayList<>();
for (String s : arr) {
boolean test = pre1.and(pre2).test(s);
if (test){
list.add(s);
}
}
return list;
}
public static void main(String[] args) {
String[] arr = { "迪麗熱巴,女", "古力娜紮,女", "馬爾紮哈,男", "趙麗穎,女"};
List<String> list = getList(s -> "女".equals(s.substring(s.indexOf(",") + 1)),
s -> s.substring(0, s.indexOf(",")).length() == 4,
arr);
System.out.println(list);
}
}
3.7 Function接口
java.util.function.Function<T, R> 接口用來根據一個類型的資料得到另一個類型的資料，前者稱為前置條件，後者稱為後置條件
抽象方法：apply
Function 接口中最主要的抽象方法為： R apply(T t) ，根據類型T的參數擷取類型R的結果。
使用的場景例如：将 String 類型轉換為 Integer 類型
public class Demo11 {
private static void method(Function<String, Integer> fun) {
Integer a = fun.apply("345");
System.out.println(a);
}
public static void main(String[] args) {
method(s -> Integer.parseInt(s) + 321);
}
}
當然，最好是通過方法引用的寫法
預設方法：andThen
Function 接口中有一個預設的 andThen 方法，用來進行組合操作。JDK源代碼如：
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
該方法同樣用于“先做什麼，再做什麼”的場景，和 Consumer 中的 andThen 差不多：
public class Demo12 {
private static void method(Function<String, Integer> fun1,
Function<Integer, String> fun2) {
String s = fun1.andThen(fun2).apply("HelloWorld");
System.out.println(s);
}
public static void main(String[] args) {
method(s -> s.indexOf("W") + 1,
i -> new String("W出現在該字元的第" + i + "位上！"));
}
}
第一個操作是找出目标字元在該字元串中位置，第二個操作是得出結論。兩個操作通過 andThen 按照前後順序組合到了一起
請注意，Function的前置條件泛型和後置條件泛型可以相同
3.8 練習：自定義函數模型拼接
題目
請使用 Function 進行函數模型的拼接，按照順序需要執行的多個函數操作為：
String str = “趙麗穎,20”;
- 将字元串截取數字年齡部分，得到字元串
- 将上一步的字元串轉換成為int類型的數字
- 将上一步的int數字加10，得到結果int數字
解答
public class Demo13 {
private static void method(String str, Function<String, String> fun1,
Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
Integer res = fun1.andThen(fun2.andThen(fun3)).apply(str);
System.out.println(res);
}
public static void main(String[] args) {
String str = "趙麗穎,20";
method(str,
s -> s.split(",")[1],
s -> Integer.parseInt(s),
i -> i + 10);
}
}
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)