[代码简化] 1 Lambda表达式

2019-11-25 本文已影响0人 LZhan

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）指向现有对象的实例方法的方法引用

[代码简化] 1 Lambda表达式

1、lambda表达式

1.1 lambda

1.2 函数式接口：

1.3 方法引用

猜你喜欢

热点阅读