376 常用函数式接口：Supplier
预定义
Java8在java.util.function包下预定义了大量的函数式接口，这里重点学习4个：
Supplier
Consumer
Predicate
Function
【Supplier】
被称为生产型接口，主要用于提供结果。
包含1个get方法，返回<>泛型。该方法不需要参数，它会按某种逻辑（由LambDa实现）返回一个<>数据。如果指定了接口泛型，get方法就会返回什么类型的数据。
【练习需求】
定义一个String getString(Supplier
---------------------------------------------
package e376aso;
import java.util.function.Supplier;
public class Demo376 {
public static void main(String[] args) {
System.out.println(getString(() -> "mole"));
System.out.println(getInteger(() -> 3));
// why nothing in the () of parameter
}
private static String getString(Supplier
return su.get();
}
private static int getInteger(Supplier
// 返回值写int是可以的，这里可以自动拆箱装箱
return suu.get();
}
}
//what the meaning of the two method? why i need them?
//mole
//3
377 Supplier练习：获取最大值
略
378 常用函数式接口：Consumer
Consumer
interface Consumer
包含2个方法：
（1个抽象方法，1个默认方法）
void accept(T t)，对给定的参数执行此操作
default Consumer
【练习需求】
定义一个方法，消费1个字符串数据
定义一个方法，消费2个字符串数据
---------------------------------------------
package e376aso;
import java.util.function.Consumer;
public class Demo378Consumer {
public static void main(String[] args) {
operateString("morning", ss -> System.out.println(ss));
operateString("abc", ss -> System.out.println(new StringBuilder(ss).reverse().toString()));
operateString("noon", System.out::println);
System.out.println(1);
operateStrings("xyz", sss -> System.out.println(sss), ssss -> System.out.println(new StringBuilder(ssss).reverse().toString()));
}
private static void operateString(String str, Consumer
con.accept(str);
}
//定义一个方法，消费1个字符串数据2次
private static void operateStrings(String str, Consumer
// con1.accept(str);
// con2.accept(str);
con1.andThen(con2).accept(str);
}
}
//morning
//cba
//noon
//1
//xyz
//zyx
379 Consumer练习：按要求打印信息
略
380 常用函数式接口：Predicate（1）
Predicate，美 [ˈpredɪkət , ˈpredɪkeɪt]
n.谓语(句子成分，对主语加以陈述，如John went home中的went home)
vt.断言;使基于;使以…为依据;表明;阐明
| 变量和类型 | 方法 | |
| 1 | default Predicate | and(Predicateother) AND，返回一个组合谓词，表示此谓词和另一个谓词的短路逻辑AND。 |
| 2 | static | isEqual(Object target R e f) ==，返回一个谓词，根据Objects.equals(Object,Object)测试两个参数是否相等。 |
| 3 | default Predicate | negate() NOT返回表示此谓词的逻辑否定的谓词。 |
| 4 | static | not(Predicatetarget) UN，返回谓词，该谓词是提供的谓词的否定。 |
| 5 | default Predicate | or(Predicateother) OR，返回一个组合谓词，表示此谓词与另一个谓词的短路逻辑OR。 |
| 6 | boolean | test(T t) 根据给定的参数计算此谓词。 |
| 7 | Predicate 判断参数是否满足指定的条件 |
【代码思路】
定义一个private static boolean checkString(String s,Predicate
（方法体里面调用test方法，没有其他代码）
【梳理】
test到底做了什么，要看Java预定义的代码，不是自己写的。话说早了，是自己写的，在调用时写。可是，main方法里写好一切不好吗，为什么要定义一个方法然后调用绕来绕去？
最近的练习的方法多是private的啊，为什么？
---------------------------------------------
package e376aso;
import java.util.function.Predicate;
public class Demo380Predicate {
public static void main(String[] args) {
boolean b1 = checkString1("hello", ss -> ss.length() < 8);
boolean b2 = checkString2("hello", ss -> ss.length() < 8);
boolean b3 = checkString2("hello", ss -> ss.length() < 8);
System.out.println(b1 + "," + b2 + "," + b3);
}
private static boolean checkString1(String str, Predicate
return pre.test(str);
}
private static boolean checkString2(String str, Predicate
return !pre.test(str);
}
private static boolean checkString3(String str, Predicate
return pre.negate().test(str);
}
}
//true,false,false
381 常用函数式接口：Predicate（2）
【练习需求】
1个字符串，2个判断条件，以2个判断结果为算子，输出运算结果
---------------------------------------------
package e376aso;
import java.util.function.Predicate;
public class Demo381Predicate2 {
public static void main(String[] args) {
boolean b44 = checkString44("hello", str1 -> str1.length() < 8, str2 -> str2.length() > 8);
boolean b55 = checkString55("hello", str1 -> str1.length() < 8, str2 -> str2.length() > 8);
System.out.println(b44 + "," + b55);
}
private static boolean checkString44(String str, Predicate
// boolean boo1 = pre1.test(str);
// boolean boo2 = pre2.test(str);
// return boo1 && boo2;
return pre1.and(pre2).test(str);
}
private static boolean checkString55(String str, Predicate
return pre1.or(pre2).test(str);
}
}
//false
382 Predicate练习：筛选满足条件数据
略
383 常用函数式接口：Function
软件包 java.util.function Interface Function
T - 函数输入的类型
R - 函数结果的类型
这是一个功能接口，因此可以用作lambda表达式或方法引用的赋值目标。
@FunctionalInterface
public interface Function
这是一个functional interface，其功能方法是apply(Object) 。
| 1 | R apply(T t) 将此函数应用于指定的参数 | |
| 2 | default andThen(Function 返回组合函数，首先将该函数应用于输入，然后将after函数应用于结果 | |
| 3 |
Function
【练习需求】
定义一个方法，把String数据转为int数据
定义一个方法，把int数据加上一个整数后转为String数据
定义一个方法，把String数据转为int数据，加上一个整数后转为String
---------------------------------------------
package e376aso;
import java.util.function.Function;
public class Demo383Function {
public static void main(String[] args) {
System.out.println(convert("99", s -> Integer.parseInt(s)));
System.out.println(convert("99", Integer::parseInt));
System.out.println(convert(98, i -> String.valueOf(i + 2)));
convert("88", s -> Integer.parseInt(s), i -> String.valueOf(i + 1));
// 方法有返回值，可作为sout的参数调用并写屏。方法无返回值，则方法体中应以sout输出。sout在main中or方法体中，要写屏，必居其一。
}
private static int convert(String s, Function
return fuu.apply(s);
}
private static String convert(int i, Function
return fuu.apply(i);
}
private static void convert(String s, Function
Integer ii = fuu1.apply(s);
String ss = fuu2.apply(ii);
System.out.println("1." + ss);
System.out.println("2." + fuu2.apply(fuu1.apply(s)));
System.out.println("3." + fuu1.andThen(fuu2).apply(s));
;
}
}
//99
//99
//100
//1.89
//2.89
//3.89
