Java8新特性之Lambda表达式

作者: ReallyZhang | 来源:发表于2017-10-15 17:24 被阅读36次
    千山鸟飞绝,万径人踪灭。 孤舟蓑笠翁,独钓寒江雪。

    写在前面

    还记得上次面试时被问到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(() -> {
               
            }))));
    
    

    当然像这种多层嵌套在开发环境中极少能遇到,知道Lambda表达式可以简化多层嵌套就OK了。

    写在后面:

    从Lambda表达式开始等于开启了Java的极简模式,期待下个版本会有更多的简化,祝福Java在简化这条路上越走越远,让嘲笑Java臃肿的人去屎

    一句话总结

    Lambda简化了单一方法接口的匿名内部类实现,以及单一方法的匿名实现;

    相关文章

      网友评论

        本文标题:Java8新特性之Lambda表达式

        本文链接:https://www.haomeiwen.com/subject/mkmnyxtx.html