Lambda表达式

Lambda表达式

晨鸣的博客–Lambda表达式

配置

下载安装Java8

因为Lambda表达式是Java 8引入的新特性，所以第一步需要配置Java 8的环境变量，Java 8 以下也可以通过插件完成对Lambda表达式的支持。

添加插件依赖

由于Android Studio默认使用Lambda是不识别的，为了方便我们在Android Studio 中使用Lambda可以通过retrolambda插件来进行开发。

首先在项目的 build.gradle 的 dependencies 节点中添加

  classpath 'me.tatarka:gradle-retrolambda:3.3.1'

然后在module的 build.gradle 中配置使用插件

    apply plugin: 'me.tatarka.retrolambda'

在 android 节点中添加

  compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
  }

配置完成就可以在项目中使用Lambda表达式了

Lambda表达式结构

Lambda表达式通常以 (argument)->{body} 格式书写

//省略参数类型
(arg1,arg2...) -> {body}

//指定参数类型
(Type1 arg1,Type2 arg2...)->{body}

通常具有以下规则

• 当参数只有一个时可省略小括号 x->{x+1}
• 当没有参数时或有多个参数时小括号不可省略 ()->{/*代码*/}
• 当表达式主体只有一条语句时，花括号可以省略(x,y)->x+y
• 当表达式主体有多条语句时，表达式的返回类型与代码块的返回类型一致
• 当表达式主体只有一条语句时，表达式的返回类型与该语句的返回类型一致

实践

简单使用

点击事件正常使用

btnTest.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.e(TAG, "点击按钮");
            }
        });

radioGroupTest.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(RadioGroup group, @IdRes int checkedId) {
                switch (checkedId) {
                    case R.id.rb_1:
                        Log.e(TAG, "选择1");
                        break;
                    case R.id.rb_2:
                        Log.e(TAG, "选择2");
                        break;
                }
            }
        });

Lambda 表达式

btnTest.setOnClickListener(v->Log.e(TAG,"点击按钮"));

radioGroupTest.setOnCheckedChangeListener((group,checkId)->{
            switch (checkId) {
                case R.id.rb_1:
                    Log.e(TAG, "选择1");
                    break;
                case R.id.rb_2:
                    Log.e(TAG, "选择2");
                    break;
            }
        });

开线程

new Thread(new Runnable() {
            @Override
            public void run() {
                /*do something*/
            }
        });


new Thread(()->{ /*do something*/});

配合Rxjava使用

写个倒数计时器

btnTime.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Observable.interval(0,1000, TimeUnit.MILLISECONDS)
                        .take(60)
                        .subscribeOn(Schedulers.newThread())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Consumer<Long>() {
                            @Override
                            public void accept(Long aLong) throws Exception {
                                btnTime.setText(60-aLong+"");
                            }
                        }, new Consumer<Throwable>() {
                            @Override
                            public void accept(Throwable throwable) throws Exception {
                                btnTime.setText("出错了");
                            }
                        }, new Action() {
                            @Override
                            public void run() throws Exception {
                                btnTime.setText("完成");
                            }
                        });

            }
        });

  btnTime.setOnClickListener(v -> {
            Observable.interval(0, 1000, TimeUnit.MILLISECONDS)
                    .take(60)
                    .subscribeOn(Schedulers.newThread())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(aLong -> btnTime.setText(60-aLong+""),
                            throwable -> btnTime.setText("出错了"),
                            ()->btnTime.setText("完成"));
        }); 

来放个大招，感受感受变态的代码缩进

 List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("huawei");
        list.add("oppo");

        Observable.fromIterable(list)
                .flatMap(new Function<String, ObservableSource<String>>() {
                    @Override
                    public ObservableSource<String> apply(String s) throws Exception {
                        return Observable.just(s + "flatMap");
                    }
                })
                .map(new Function<String, String>() {
                    @Override
                    public String apply(String s) throws Exception {
                        return s+"的长度为："+s.length();
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e("Test", s);
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                            throwable.printStackTrace();
                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {
                        Log.e("Test","完成");
                    }
                });

使用Lambda表达式

Observable.fromIterable(list)
                .flatMap(s->Observable.just(s+" flatmap"))
                .map(s-> s+" 的长度为："+s.length())
                .subscribe(s->  Log.e("Test",s),Throwable::printStackTrace,()->Log.e("Test","完成"));

爽！

小结

使用Lambda表达式可以大大减少程序中匿名内部类的书写，虽然现在大部分的 ide 都支持自动生成代码，但是过多的匿名内部类依然会导致代码乱，且不方便阅读。使用Lambda表达式可以使代码更简洁，对于代码洁癖者是大大的福音啊。。。