Java8新特性之Lambda表达式

最新推荐文章于 2019-04-25 17:13:36 发布

星光小站

最新推荐文章于 2019-04-25 17:13:36 发布

阅读量337

点赞数

分类专栏： java8 lambda

本文链接：https://blog.csdn.net/qq_33923079/article/details/78935633

版权

lambda 同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

java8

0 篇文章 0 订阅

订阅专栏

!千山鸟飞绝，万径人踪灭。
孤舟蓑笠翁，独钓寒江雪。

写在前面

还记得上次面试时被问到Java8新特性，我当时居然脑袋一片空白，然后就GAME OVER了。刚走到大门口才想起来Lambda表达式这个点，真的是有点失望，现在想想主要原因是自己在项目中没有使用，只是停留在了解层面，没有用到项目其实就是就是不会！！

就像这Markdown编辑器一个月没写博客，都不会用了。尴尬，一不小心就暴露自己的懒。

好了废话少说，开始搞正事。

Java8新特性中的其他特性，这里就不说了，主要原因是不能兼容Android7.0以下。

Lambda表达式说白了就是一种匿名方法，不需要方法名，修饰符，和返回值类型。

使用方法

首先在moudle的build.gradle文件中添加配置：app/build.gradle添加。

android {
        ...
        defaultConfig {
        ...
        jackOptions.enabled=true;
    }
    compileOptions{
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    ...
}

就这样配置就OK了；

接下来我们来看看怎么使用；

首先拿一个点击事件来比对一下：
一般写法

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

            }
        });

解说：这是一种匿名内部类的写法，较之外部类的写法已经算是很简洁了。

Lambda表达式*

        button.setOnClickListener(view ->{

        });

解说：不难发现，Lambda的这种写法连匿名内部类都不用写了，更加简洁了，直接将参数暴露在外，在方法体中可以直接调用该参数；如果没有参数就用()就行，例如开启线程的写法：

            new Thread(() -> {

            });

到这里大家可能就要说了：不就是少了两行代码，有什么了不起，学的时候还不是要从匿名内部类写起？

放个大招给你们瞅瞅，在点击事件中开启一个线程的：
一般写法

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                new Thread(new Runnable() {
                    @Override
                    public void run() {

                    }
                });
            }
        });

看起来是不是有点眼花缭乱，很明显的onClick等方法有点抢镜，让run方法不是那么容易被发现；

Lambda表达式

        button.setOnClickListener( view-> new Thread(() -> {

        }));

怎么样，是不是被惊艳到了，服不服？？Lambda就是这么简洁，简洁到没朋友。

可能有朋友就奇怪怎么写一起了，不该是两个分开的Lambda表达式，像这样吗，嵌套在一起怎么变样了？

        button.setOnClickListener(view -> {
            new Thread(() -> {

            });
        });

带着这个疑问我们从源头找起，来看看Lambda表达式到底简化了什么？
从上面几个例子我们不难发现，Lambda表达式的简化，其实是简化了接口的匿名内部类的实现和方法：

        //一般写法
        View.OnClickListener listener=new View.OnClickListener() {
            @Override
            public void onClick(View view) {

            }
        };
        //Lambda表达式
        View.OnClickListener listener= view -> {

        };

比如在这里Lambda简化了OnClickListener这个接口的匿名实现和一个必须实现的方法onClick，只留下一个参数View。

那么到这里，我们大概了解了Lambda表达式的作用，但是心中却产生了疑问，Lambda表达式的使用范围广不广？
比如下面提出的一些疑问：

Lambda表达式只能简化接口的匿名实现吗？
Lambda表达式能简化多个方法的接口的匿名实现吗？
Lambda表达式能简化方法里有多个参数的接口吗？
Lambda表达式能简化方法带有返回值的接口吗？

OK，接下来我们来一一解答：

Lambda表达式只能简化接口的匿名实现吗？

答案是肯定的。

就目前而言Lambda表达式只能简化接口的匿名内部类实现。
原因大概是：接口是没有构造方法，而抽象类和一般的类是有构造方法的；接口里的方法没有方法体等等。因为接口的特殊性，Lambda表达式就是只针对接口而已。

Lambda表达式能简化多个方法的接口的匿名实现吗？

答案是不能：这里从Lambda的表达式就可以看出来，已经简化到没有没有一丝多余的代码，多个方法怎么写呢。

结论：

Lambda只能简化了单一方法接口的实现，以及方法的匿名实现；

Lambda表达式能简化多个参数的单一方法接口吗？

这个答案是肯定的。

前面我在例子中已经用到了没有参数和一个参数的接口匿名实现。
- 没有参数一个空的小括号；
- 一个参数在括号里面添加一个参数，
- 多个参数就直接添加就OK了；
- 一个参数时小括号是可以省略的；
- 另外参数类型是可以省略的，当然也就可以写的；
- 省略括号时是不能写参数类型的。

示例如下：

        //没有参数
        Runnable runnable=() -> {

        };

        //一个参数
        View.OnClickListener listener= (View view) -> {

        };
        View.OnClickListener listener= (view) -> {
                  //参数类型可省略
        };
       View.OnClickListener listener= view -> {
                  //括号可省略，但不能添加参数
        };

        //两个参数
        public interface JackListener{
               void check(String string,String check);
        };
        doWhat("jack666", (string, check) -> {
                //这里的两个参数指的是接口里方法的参数，而不是doWhat的参数哦
        });

Lambda表达式能简化方法带有返回值的接口吗？

答案是肯定的，其实返回值和简化前的写法是一样，return一下就可以了。
示例如下：

         //两个参数
        public interface JackListener{
            boolean check(String string,String check);
        };
        doWhat("jack666", (string, check) -> {
            boolean result=string.contains(check);
            Toast.makeText(MainActivity.this, ""+result, Toast.LENGTH_SHORT).show();
            return result;
        });

解答完上述几个问题，我们也就了解了Lambda表达式使用范围是针对单一方法接口的匿名实现，是有很强的针对性，并不是哪里都能用的，不过就目前的面向接口编程的大环境下还是有不小的使用空间。

那现在咱们再来看看最前面的那个问题：两个Lambda表达式嵌套时，发生的化学反应：

        button.setOnClickListener(view -> {
            new Thread(() -> {

            });
        });
        //两个Lambda表达式嵌套，极简模式
        button.setOnClickListener( view-> new Thread(() -> {
            //前提是Lambda表达式中的方法体内部只有一个单纯Lambda表达式
        }));

到这里，不难发现外层Lambda表达式的方法体被简化了，而将内部的Lambda表达式衔接在了外层后面，就形成了这种极简的写法；

那么Lambda表达式能简化多个Lambda表达式的嵌套吗，带着好奇心，我尝试了四个Lambda表达式的嵌套：

        //一般写法
         button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        button.setOnClickListener(new View.OnClickListener()         {
                            @Override
                            public void onClick(View view) {
                                new Thread(new Runnable() {
                                    @Override
                                    public void run() {

                                    }
                                });
                            }
                        });
                    }
                });
            }
        });
        //四个Lambda表达式嵌套，CRAZY!!!
        button.setOnClickListener(view -> new Thread(() -> 
              button.setOnClickListener(view1 -> new Thread(() -> {

        }))));