参考：https://blog.csdn.net/jmj18756235518/article/details/81490966
函数式接口
定义：有且只有一个抽象方法的接口
Function<T, R>： y = f(x) T: x 输入参数, R: 返回结果，y
所有标注了@FunctionalInterface注解的接口都是函数式接口，所有标注了该注解的接口都将能用在lambda表达式上
特点：通过传入不同的Function，实现了在同一个方法中实现不同的操作，在实际开发中可以大大减少很多重复的代码。
例如：新增用户的功能，用户分为VIP和普通用户，且有两种不同的新增逻辑。那么此时我们就可以先写两种不同的逻辑。除此之外，这样还让逻辑与数据分离开来，我们可以实现逻辑的复用。
函数式编程与非函数式编程的区别
函数式编程： 先考虑传入的参数，再考虑方法的实现
非函数式编程：先定义好方法，再传入指定的参数
/**
* 需求
* 1.定义一个函数式接口CurrentTimePrinter,其中抽象方法void printCurrentTime()，使用注解@FunctionalInterface
* 2.在测试类中定义static void showLongTime(CurrentTimePrinter timePrinter)，该方法的预期行为是使用timePrinter打印系统当前毫秒值
* 3.测试showLongTime(),通过lambda表达式完成需求
*/
@FunctionalInterface
public interface CurrentTimePrinter {
void printCurrentTime();
}
测试类
public class FunctionalInterfaceTest {
/**
* 打印当前系统的毫秒值
* @param timePrinter
*/
public static void showLongTime(CurrentTimePrinter timePrinter){
timePrinter.printCurrentTime();
}
public static void main(String[] args) {
showLongTime(() -> System.out.println(System.currentTimeMillis()));
}
}
/**
* 需求
* 1.定义一个函数式接口IntCalc,其中抽象方法int calc(int a , int b)，使用注解@FunctionalInterface
* 2.在测试类中定义static void getProduct(int a , int b ,IntCalc calc), 该方法的预期行为是使用calc得到a和b的乘积并打印结果
* 3.测试getProduct(),通过lambda表达式完成需求
*/
@FunctionalInterface
public interface IntCalc {
int calc(int a , int b);
}
测试类：
/**
* 需求
* 定义static void getProduct(int a , int b ,IntCalc calc), 该方法的预期行为是使用calc得到a和b的乘积并打印结果
*/
public class FunctionalInterfaceTest02 {
static void getProduct(int a , int b ,IntCalc calc){
int result = calc.calc(a, b);
System.out.println(result);
}
public static void main(String[] args) {
getProduct(2,3, (a, b) -> a*b);
}
}
静态方法的引用
/**
* 1.定义一个函数式接口NumberToString,其中抽象方法String convert(int num)，使用注解@FunctionalInterface
* 2.在测试类中定义static void decToHex(int num ,NumberToString nts),
* 该方法的预期行为是使用nts将一个十进制整数转换成十六进制表示的字符串，tips:已知该行为与Integer类中的toHexString方法一致
* 3.测试decToHex (),使用方法引用完成需求
*/
@FunctionalInterface
public interface NumberToString {
String convert(int num);
}
测试类
public class FunctionalInterfaceTest03 {
/**
* 需求：
* 在测试类中定义static void decToHex(int num ,NumberToString nts),
* 该方法的预期行为是使用nts将一个十进制整数转换成十六进制表示的字符串，tips:已知该行为与Integer类中的toHexString方法一致
*/
public static void main(String[] args) {
//NumberToString类的方法的实现使用了Integer 类的toHexString 方法
decToHex(999, Integer::toHexString);
}
public static void decToHex(int num ,NumberToString nts){
String convert = nts.convert(num);
System.out.println(convert);
}
}
使用函数式编程来实现延迟加载
Predicate的使用（构造断言式）：
简介：predicate是一个接口，含有一个抽象方法test()，含有4个由default修饰的具体实现方法and()、or()、negate()、isEquals()
and()对应java的连接符 &&；
or()对应java的连接符 || ；
negate()对应java的连接符 ! ；
isEquals对应java的连接符 == ；
package com.test.stream;
/**
* @program: basic-java
* @Author:chenxuebing
* @Date:2019-09-16 9:25
* @Description:(描述)
*/
import java.util.function.Predicate;
/**
* 需求：1.请在测试类main方法中完成以下需求
* 已知有Integer[] arr = {-12345, 9999, 520, 0,-38,-7758520,941213}
* a)使用lambda表达式创建Predicate对象p1,p1能判断整数是否是自然数(大于等于0)
* b)使用lambda表达式创建Predicate对象p2,p2能判断整数的绝对值是否大于100
* c)使用lambda表达式创建Predicate对象p3,p3能判断整数是否是偶数
*
* 遍历arr，仅利用已创建的Predicate对象(不使用任何逻辑运算符)，完成以下需求
* i.打印自然数的个数
* ii.打印负整数的个数
* iii.打印绝对值大于100的偶数的个数
* iv.打印是负整数或偶数的数的个数
*/
public class Test01 {
public static void main(String[] args) {
Integer[] arr = {-12345, 9999, 520, 0,-38,-7758520,941213};
Predicate<Integer> p1 = (t) -> t >= 0;
Predicate<Integer> p2 = (t) -> Math.abs(t) > 100;
Predicate<Integer> p3 = (t) -> t % 2 == 0;
int count1 = 0;
int count2 = 0;
int count3 = 0;
int count4 = 0;
for(int a : arr){
//自然数个数
if(p1.test(a)){
count1++;
}
//绝对值大于100的偶数的个数
if(p2.and(p3).test(a)){
count2++;
}
//负整数的个数
if(p1.negate().test(a)){
count3++;
}
//负整数或偶数的数的个数
//先找满足条件的负整数，再找满足条件的偶数，然后取交集，p1.negate(),!p1.test(),p3.test()取交集
if(p1.negate().or(p3).test(a)){
count4++;
}
}
System.out.println("自然数"+ count1);
System.out.println("绝对值大于100的偶数的个数"+ count2);
System.out.println("负整数的个数"+ count3);
System.out.println("负整数或偶数的数的个数"+ count4);
}
}
Function接口的使用
简介：含有一个抽象方法R apply（T t), 两个default修饰的实现了的方法compose(), andThen()
特点：
f1.compose(f2).apply(T) : 先执行f2.apply(T), 再执行f1.apply(f2.apply(T))
compose接收一个Function参数，返回时先用传入的逻辑执行apply，然后使用当前Function的apply
f1.andThen(f2).apply(T): 先执行f1.apply(T) , 再执行分f2.apply(f1.apply(T))
andThen跟compose正相反，先执行当前的逻辑，再执行传入的逻辑。
/**
* 需求
* 1.使用lambda表达式分别将以下功能封装到Function对象中
* a)求Integer类型ArrayList中所有元素的平均数
* b)将Map<String,Integer>中value存到ArrayList<Integer>中
* 2.已知学生成绩如下
* 姓名 成绩
* 岑小村 59
* 谷天洛 82
* 渣渣辉 98
* 蓝小月 65
* 皮几万 70
* 3.以学生姓名为key成绩为value创建集合并存储数据，使用刚刚创建的Function对象求学生的平均成绩
*/
public class FunctionTest {
public static void main(String[] args) {
//使用Lambda表达式求Integer类型ArrayList中所有元素的平均数
Function<ArrayList<Integer>, Integer> f1 = (list) -> {
int sum = 0;
int count = 0;
for(Integer score : list){
sum += score;
count++;
}
return sum/count;
};
//使用Lambda表达式将Map<String,Integer>中value存到ArrayList<Integer>中
Function<Map<String, Integer>, ArrayList<Integer>> f2 = (map) -> {
ArrayList<Integer> scoreList = new ArrayList<>();
Collection<Integer> values = map.values();
for(Integer score : values){
scoreList.add(score);
}
return scoreList;
};
//以学生姓名为key成绩为value创建集合并存储数据
Map<String,Integer> map = new HashMap<String, Integer>();
map.put("岑小村", 59);
map.put("谷天洛", 82);
map.put("渣渣辉", 98);
map.put("蓝小月", 65);
map.put("皮几万", 70);
//使用刚刚创建的Function对象求学生的平均成绩
//f1.compose(f2).apply(map),先求f2.apply(map),再求 f1.apply(f2.apply(map)),f2.apply(map)的返回值作为f1的apply的参数值
int averge = f1.compose(f2).apply(map);
System.out.println(averge);
}
}
Supplier接口（生产者）
简介：Supplier函数式接口
T get()抽象方法，返回一个T类型的对象
import java.util.function.Supplier;
/**
* Supplier函数式接口
* 抽象方法 T get(): 返回一个T类型的对象
*/
public class SupplierTest {
//Supplier<String> supplier 的泛型为String，那么它的get 方法返回对象也是一个String类型
public static String getString(Supplier<String> supplier){
return supplier.get();
}
public static void main(String[] args) {
//若方法体只有一条语句可以省略{} 和 return
String result = getString(() -> "胡歌");
System.out.println(result);
}
}
Consumer接口（消费者）
import java.util.function.Consumer;
/**
* Consumer函数式编程接口
* void accept(T t)方法, 用来做消费
*/
public class ConsumerTest {
//对String类型的对象进行消费
public static void method(String name, Consumer<String> consumer){
consumer.accept(name);
}
public static void main(String[] args) {
//对name，进行消费，反转打印姓名
method("赵丽颖", name -> {
StringBuilder builder = new StringBuilder();
builder.append(name);
System.out.println(builder.reverse().toString());
});
}
}
andThen（）方法
/**
* andThen(Consumer)
* consumer1.andThen(consumer2).accept(T)
* 先执行consumer1.accept(T),再执行consumer2.accept(T),因为T是对象，consumer1对对象进行消费后对象发生变化
* 随着consumer2消费的对象是consumer1消费后的对象
*/
public class ConsumerAndThenTest {
public static void method (int[] arr, Consumer<int[]> consumer1, Consumer<int[]> consumer2){
consumer1.andThen(consumer2).accept(arr);
}
public static void main(String[] args) {
method(new int[]{1, 3, 5, 6},
//将数组的第一个元素改为0
arr -> {
System.out.println( arr[1] = 0);
System.out.println(arr.toString());
},// 0, 3, 5, 6
//将数组的第一个元素改为1
arr -> {
System.out.println(arr[2] = 2); // 2, 3, 5, 6
System.out.println(arr[1]);
}
);
}
}