1、lambda表达式
1.1 lambda
利用lambda表达式代替匿名参数类，将行为进行参数化传递到代码中，由代码动态调用。
举例，给定一个实体列表，根据实体的某个属性进行筛选。
<1> 这种情况下，最开始的做法就是：
public static List<Sku> filterElectronicsSkus(List<Sku> skuList){
List<Sku> result=new ArrayList<>();
for (Sku sku:cartSkuList){
if (SkuCategoryEnum.ELECTRONICS.equals(sku.getSkuCategory())){
result.add(sku);
}
}
return result;
}
硬编码，进行指定条件筛选。
<2> 如果，再根据某个属性的其他值进行筛选，进一步做法：
除了原始列表，也会将条件作为参数之一
public static List<Sku> filterSkusByCategory(List<Sku> skuList,SkuCategoryEnum category){
List<Sku> result=new ArrayList<>();
for (Sku sku:cartSkuList){
if (category.equals(sku.getSkuCategory())){
result.add(sku);
}
}
return result;
}
<3> 如果，不仅仅是根据category这一个属性，可能还会根据price等别的属性筛选：
先定义一个接口
public interface SkuPredicate {
/**
* 选择判断标签
* @param sku
*/
boolean test(Sku sku);
}
定义接口实现类：
public class SkuBooksCategoryPredicate implements SkuPredicate {
@Override
public boolean test(Sku sku) {
return SkuCategoryEnum.BOOKS.equals(sku.getSkuCategory());
}
}
public class SkuTotalPricePredicate implements SkuPredicate {
@Override
public boolean test(Sku sku) {
return sku.getTotalPrice()>2000;
}
}
之后，再出现别的筛选条件，只需要多定义一个接口实现类就可以了
public void filterSkus() {
List<Sku> cartSkuList = CartService.getCartSkuList();
//过滤商品总价大于2000的商品
List<Sku> res = CartService.filterSkus(cartSkuList, new SkuTotalPricePredicate());
System.out.println(JSON.toJSONString(res, true));
}
<4> 我们会发现，这样下去，接口实现类会越来越多，并且这些接口实现类往往复用的机会并不多，所以会想到使用匿名类代替。
public void filterSkus1() {
List<Sku> cartSkuList = CartService.getCartSkuList();
//过滤商品sku价大于2000的商品
//todo 这里的接口实现类只会使用一次,所以可以在这里直接使用匿名内部类
List<Sku> res = CartService.filterSkus(cartSkuList, new SkuPredicate() {
@Override
public boolean test(Sku sku) {
return sku.getSkuPrice() > 3000;
}
});
System.out.println(JSON.toJSONString(res, true));
}
<5> 对于匿名内部类，我们可以使用lambda表达式来代替
public void filterSkus2() {
List<Sku> cartSkuList = CartService.getCartSkuList();
//过滤商品sku价大于2000的商品
//todo 这里的接口实现类只会使用一次,所以可以在这里直接使用匿名内部类
List<Sku> res = CartService.filterSkus(cartSkuList, sku -> sku.getSkuPrice() > 1000);
System.out.println(JSON.toJSONString(res, true));
}
从上面可以总结：函数编程演化历程：
Lambda表达式：
两种形式
- (parameters) -> expression
- (parameters) -> {statement;}
语法简写形式：
(1) 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。 即()里面无需声明参数类型。()里面甚至可以什么都没有
(2) 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。 即()可以省略。
(3) 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。 即{}可以省略，同时语句后面的分号也可以省略。
(4) 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。
形式：
(1) 没有参数，小括号不能省略
() -> System.out.println("Hello World");
(2) 只有一个参数，小括号可省略
name -> System.out.println("Hello World"+name+"!");
(3) 没有参数，逻辑复杂
() ->
{
System.out.print("Hello");
System.out.println(" World");
};
(4)
// 创建一个函数
BinaryOperator<Long> functionAdd = (x, y) -> x + y;
// 应用函数，给函数传值，得到计算结果
Long result = functionAdd.apply(1L, 2L);
(5) 对参数类型的显示声明
// 创建一个函数
BinaryOperator<Long> function = (Long x, Long y) -> x + y;
// 应用函数，给函数传值，得到计算结果
Long result = function.apply(1L, 2L);
1.2 函数式接口：
允许将函数本身作为参数传入另一个函数。
- 接口中有且只有一个抽象方法，但是可以有多个非抽象方法
- Java8的函数式接口注解：@FunctionalInterface
该注解可用于一个接口的定义上，一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。
自定义函数示例：
@FunctionalInterface
public interface FileConsumer {
void fileHandler(String fileContent);
}
public class FileService {
public void fileHandle(String url, FileConsumer fileConsumer) throws IOException {
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(url)));
String line;
StringBuilder stringBuilder = new StringBuilder();
//循环读取文件内容
while ((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line + "\n");
}
fileConsumer.fileHandler(stringBuilder.toString());
}
}
public class FileServiceTest {
@Test
public void fileHandle() throws IOException {
FileService fileService=new FileService();
fileService.fileHandle("文件路径",fileContent -> System.out.println(fileContent));
}
}
结果输出该指定文件路径下的文件内容。
常用函数接口：
在java.util.function包下。
1.3 方法引用
调用特定方法的Lambda表达式的一种快捷写法，可以让你重复使用现有的方法定义，并像Lambda表达式一样传递。
（1）指定静态方法的方法引用：
Integer::parseInt
List<String> strs= Lists.newArrayList("1","33","44","66");
System.out.println(strs.stream().map(Integer::parseInt).max(Ordering.natural()).get());
（2）指向任意类型实例方法的方法引用：
（3）指向现有对象的实例方法的方法引用
