java8 lambda学习分享

lambda学习经验分享（由邮件中copy，可以跟着思路，但不必揪其中类名不懂）

lambda的组成：

表达式分为三个部分组成 1）参数列表 2）箭头 -> 3) lambda主体

语法规则

（parameters） -> expression

(parameters) -> { statements； }

lambda学习之前你需要了解的理论知识（简单概括）：

1）行为参数化：

行为参数化就是将代码块传递给另一个方法（作为方法的参数），在方法中去执行传入的代码块

2）匿名类

匿名类没有名字，它允许你同时声明并实例化一个类，优点：随时用随时创建

3）函数式接口

可以有很多默认方法，但是有且只有一个抽象方法。

4）

按照特定的业务需求，建立起符合自己业务流程的行为载体（函数式接口），和运用该行为的逻辑代码块

学习lambda表达式，过程

第一步：明确那些行为可以对其进行行为参数

举例：Gmp（一个项目名称）中许多采取了多结果集形式，但是多结果集返回时候，我们要对其进行过滤筛选进行反序列化。

例如返回五个结果集，我们就会进行五次以下的序列化过程（这部分代码是很啰嗦的，看起来唯一不同的地方就是过滤条件不同，过滤后插入的数组不同）

下面语句目的：过滤出dbOutlet_Drawing 集合中属性 DrawingId 等于类 tempBug 中 DrawingId 的类，将其加入到tempOutboundBug

for (Entities.Entity_Drawing tempDrawing:dbOutlet_Drawing) {
    if (tempBug.DrawingId.equals(tempDrawing.DrawingId)){
        tempOutboundBug.BugDrawing.add(tempDrawing);
    }
}
for (Entities.Entity_BugPhoto tempBugPhoto:dbOutlet_BugPhoto) {
    if(tempBugPhoto.BugId.equals(tempBug.BugId)){
        tempOutboundBug.BugPhotoList.add(tempBugPhoto);
    }
}

第二步：使用lambda表达式进行优化（简单的优化）

dbOutlet_Drawing.forEach(tempDrawing ->{
    if (tempBug.DrawingId.equals(tempDrawing.DrawingId)){
        tempOutboundBug.BugDrawing.add(tempDrawing);
    }
});
dbOutlet_BugPhoto.forEach(tempBugPhoto ->{
    if(tempBugPhoto.BugId.equals(tempBug.BugId)){
        tempOutboundBug.BugPhotoList.add(tempBugPhoto);
    }
});

我们可以看见大量的 for语句已经被 lambda替换掉了，但是你的感觉一定是，只是外观好看了一点嘛，代码也没见得少了很多，没有必要这么写，还不好懂

那是我们还没有用好lambda这个强大的功能。

第三步：在第一步的代码中和第二步的代码中我们应该有感觉，只是过滤条件不同，和插入的数组不同。

这时我们可以确定我们要行为参数化那些代码块，就是那些标注紫色的代码块。

开始进行行为参数化

1)明确行为参数化的签名（也就是规则，入参和出参。我们根据不同的签名来选择不同的函数式接口）

查看我们要行为参数化的代码块，明确其规则为出参：boolean 入参：一个对象

在java8 中我们有这样一个函数式接口 Predicate ，它的入参为 T泛型对象，出参为 boolean 类型，里面的抽象方法为 test。我们可以让这个 Predicate 接口作为我们的行为参数化的载体，传入到接下来我们定义的规范建模的代码块中

    public interface Predicate<T> {
        boolean test(T t);}

按照需求规范建模

        1）我们已经有了行为载体，Predicate函数式接口

        2）符合业务逻辑的  运用该行为的代码逻辑块

           代码前后文 ：

ArrayList<Entities.Entity_Drawing> dbOutlet_Drawing= (ArrayList<Entities.Entity_Drawing>)dbResult.get(0);
    ArrayList<Entities.Entity_Region> dbOutlet_Regin= (ArrayList<Entities.Entity_Region>)dbResult.get(1);
    dbOutlet_Drawing.forEach(tempDrawing ->{
                        Outbounds.OutboundDrawing temp_OutboundDrawing = new Outbounds.OutboundDrawing();
        temp_OutboundDrawing.RegionGroup = new ArrayList<>();
        temp_OutboundDrawing.RegionList = new ArrayList<>();
        temp_OutboundDrawing.Drawing = tempDrawing;
        temp_OutboundDrawing.RegionList = filter(dbOutlet_Regin,(Entities.Entity_Region tempRegin) -> tempRegin.DrawingId.equals(tempDrawing.DrawingId));
    });

   运用时lambda表达式：

temp_OutboundDrawing.RegionList =

    filter(dbOutlet_Regin,(Entities.Entity_Region tempRegin) -> tempRegin.DrawingId.equals(tempDrawing.DrawingId))

下面的代码块虽然使用起来简单了好多，但是只能针对Entities.Entity_Region这一个类，难道我们还要为每一个需要使用过的类

定义这样一个方法吗？答案一定是否定的，我们还需要对其进行优化。

public static  ArrayList<Entities.Entity_Region> filter(ArrayList<Entities.Entity_Region> list, Predicate<Entities.Entity_Region> ){

ArrayList<Entities.Entity_Region> result = new ArrayList<>();

        list.forEach(str ->{

            if(p.test(str)){

                result.add(str);

});

        return result;

这里的优化（抽象化）：将固定的对象改为泛型，这样适用的范围更广

    public static <T> ArrayList<T> filter(ArrayList<T> list, Predicate<T> p){
        ArrayList<T> result = new ArrayList<>();
        list.forEach(str ->{
            if(p.test(str)){
                result.add(str);
            }
        });
        return result;
    }

第四步：进行使用啦

使用规则：对一个list进行过滤，然后将符合条件的对象数组返回

例如Region类可以使用

temp_OutboundDrawing.RegionList = 
    lambdaFilter.filter(dbOutlet_Regin,(Entities.Entity_Region tempRegin) -> tempRegin.DrawingId.equals(tempDrawing.DrawingId));

RegionGroup类可以使用

temp_OutboundDrawing.RegionGroup =
    lambdaFilter.filter(dbOutlet_ReginGroup,(Outbounds.outbound_RegionGroup tempRegionGroup) 
                    ->tempRegionGroup.DrawingId.equals(tempDrawing.DrawingId));

 Bug类可以使用

responseMarker.BugList = 
    lambdaFilter.filter(dbOutlet_Bug,(Entities.Entity_Bug tempBug) -> tempBug.MarkerId.equals(tempMarker.MarkerId));

所有符合我们建模规范逻辑的类都可以使用。这样你的代码中就不会有

第一种

for (Entities.Entity_Drawing tempDrawing:dbOutlet_Drawing) {
    if (tempBug.DrawingId.equals(tempDrawing.DrawingId)){
        tempOutboundBug.BugDrawing.add(tempDrawing);
    }
}

第二种（以为自己用了lambda，其实不然）
dbOutlet_Drawing.forEach(tempDrawing ->{
    if (tempBug.DrawingId.equals(tempDrawing.DrawingId)){
        tempOutboundBug.BugDrawing.add(tempDrawing);
    }
});

你可以随意写

responseMarker.BugList = lambdaFilter.filter(dbOutlet_Bug,(Entities.Entity_Bug tempBug) 
responseMarker.BugList = lambdaFilter.filter(dbOutlet_Bug,(Entities.Entity_Bug tempBug) -> tempBug.MarkerId.equals(tempMarker.MarkerId));
tempOutboundBug.BugDrawing = lambdaFilter.filter(dbOutlet_Drawing,(Entities.Entity_Drawing draw) -> tempBug.DrawingId.equals(draw.DrawingId));BugPhotoList = lambdaFilter.filter(dbOutlet_BugPhoto,(Entities.Entity_BugPhoto bugPhoto) -> tempBug.BugId.equals(bugPhoto.BugId));
tempOutboundBug.BugFollowList = lambdaFilter.filter(dbOutlet_BugFollow,(Entities.Entity_BugFollow bugFollow) -> tempBug.BugId.equals(bugFollow.BugId));
tempOutboundBug.BugOperationList = lambdaFilter.filter(dbOutlet_BugOperation,(Entities.Entity_BugOperation bugOperation) -> tempBug.BugId.equals(bugOperation.BugId));

总结：对于本篇文章内容可以用于过滤一个集合，并且将过滤后符合条件的结果赋值给另一个集合。这篇主要介绍了行为抽象化，

以及将方法抽象化使其应用范围更广。

其实对于一个集合的过滤没有那么麻烦，下一章将讲述用其 内置函数式接口 和 java8 的 stream（流） 来对类进行过滤。

java8 lambda学习分享

猜你喜欢