说明
我们想使用 lambda表达式，需要创建 函数式接口，频繁创建接口，繁琐，也造成接口太多
一般 常用的 函数式接口，就不需要创建了，直接使用这 四大函数式接口 即可
在 java.util.function 包内 , 有Java 内置核心四大函数式接口
应用场景
将 不需改动 的代码封装到方法中，方法有2个形参：
- 数据
- 核心算法
调用时，只需传入 数据、核心算法 即可
Consumer 消费型接口
接收一个参数，根据传入算法，对该参数进行处理，没有返回值
抽象方法
void accept(T t);
形参：一个参数
返回值： 无
案例
定义一个 handle 方法，可以传入 数据、Consumer
public class ConsumerTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("李雷", "韩梅梅", "lucy", "lili");
// 将 lambda表达式 传给 handle() 方法的 Consumer 类型参数
handle(list, t -> System.out.println(t));
// 将 方法引用 传给 handle() 方法的 Consumer 类型参数
handle(list, System.out::println);
}
public static void handle(List<String> list, Consumer<String> con){
for ( String item : list) {
// 通过 accept() 方法，执行上面传入的 lambda表达式 或 方法引用，无返回结果
con.accept(item);
}
}
}
Supplier 供给型接口
根据传入算法，返回一个结果
抽象方法
T get();
形参：无
返回值： 返回一个任意类型的结果
案例
public class SupplierTest {
public static void main(String[] args) {
// 将 lambda表达式写法 传给 randomList() 方法的 Supplier 类型参数
randomList(10 , () -> Math.random() );
// 将 方法引用 传给 randomList() 方法的 Supplier 类型参数
randomList(10 , Math::random);
}
public static List<Double> randomList(int num, Supplier<Double> sup){
List<Double> list = new ArrayList<>();
for (int i = 0; i < num; i++) {
// 通过 get() 方法，执行上面传入的 lambda表达式 或 方法引用，并返回结果
Double n = sup.get();
list.add(n);
}
return list;
}
}
Predicate 断定型接口
接收一个参数，根据传入 算法，判断该 参数 是否满足条件，满足条件返回 true，否则返回 false
抽象方法
boolean test(T t);
形参：一个参数
返回值： 返回 boolean 类型，满足条件返回 true，否则返回 false
例子
定义一个 filter 方法，传入 数据、Predicate 判断条件
public class PredicateTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("李雷", "韩梅梅", "lucy", "lili","李四");
// 将 lambda 表达式传给 filter() 方法的 Predicate 类型参数
List<String> resList = filter(list, (s) -> "李".equals(s.substring(0,1)));
for (String item : resList) {
System.out.println(item);
}
}
//将不需改动的代码封装到方法中，传入数据 和 核心算法
public static List<String> filter(List<String> list, Predicate<String> pre){
List<String> retList = new ArrayList<>();
for (String str : list) {
//通过 test() 方法，执行上面传入的 lambda 表达式，判断是否符合条件，符合返回true，否则返回false
if(pre.test(str)){
retList.add(str);
}
}
return retList;
}
}
Function 函数型接口
接收一个参数，返回一个任意类型结果
抽象方法
R apply(T t);
形参：一个参数
返回值： 返回一个任意类型结果
案例
public class FunctionTest {
public static void main(String[] args) {
String[] array = new String[]{"90","80","85","92"};
// 将 lambda表达式 传给 handle() 方法的 Function类型参数
List list = handle(array,s -> Integer.parseInt(s));
System.out.println(list);
// 将 方法引用 传给 handle() 方法的 Function类型参数
List list2 = handle(array,Integer::parseInt);
System.out.println(list2);
}
public static List<Integer> handle(String[] array, Function<String,Integer> fun){
List<Integer> retList = new ArrayList<>();
for(String item : array){
// 通过 apply() 方法执行上面传入的 lambda表达式 或 方法引用，返回任意类型结果
int i = fun.apply(item);
retList.add(i);
}
return retList;
}
}
感谢：
https://www.cnblogs.com/myseries/p/13873788.html