Lambda表达式 For Android

概述Lambda简介Alambdaexpressionisablockofcodewithparameters.lambda表达式是带参数的代码块。虽然看着很先进，其实Lambda表达式的本质只是一个”语法糖”,由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。本人建议不要乱用(前提是接手 Lambda简介

A lambda Expression is a block of code with parameters. lambda表达式是带参数的代码块。

虽然看着很先进，其实Lambda表达式的本质只是一个”语法糖”,由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。本人建议不要乱用(前提是接手的开发人员没有学过Lambda),因为这就和某些很高级的***写的代码一样（简洁,难懂,难以调试）

Lambda表达式可以和RxJava结合，写出简洁优雅的高质量代码,大大缩短代码量；

 

为什么要使用Lambda表达式

随着回调模式和函数式编程风格的日益流行，我们需要在Java中提供一种尽可能轻量级的将代码封装为数据（Model code as data）的方法。匿名内部类并不是一个好的选择，因为：

语法过于冗余

匿名类中的this和变量名容易使人产生误解

类型载入和实例创建语义不够灵活

无法捕获非final的局部变量

无法对控制流进行抽象

上面的多数问题均在Java SE 8中得以解决：

通过提供更简洁的语法和局部作用域规则，Java SE 8彻底解决了问题1和问题2

通过提供更加灵活而且便于优化的表达式语义，Java SE 8绕开了问题3

通过允许编译器推断变量的“常量性”（finality），Java SE 8减轻了问题4带来的困扰

让AndroID Stutio支持Lambda

目前AndroID开发工具已经从Eclipse 的ADT迁移到了AndroID Studio，但是AndroID Studio目前还没有直接支持Lambda，需要插件retrolambda 支持，当然，JDK版本也必须使用JDK 8 或者以上。按照下面步骤配置Gradle：

首先先项目根目录下的build.gradle中加入

1 classpath 'me.tatarka:gradle-retrolambda:3.6.1'

然后再module目录下的build.gradle中使用插件，加入

1 apply plugin: 'me.tatarka.retrolambda'

并且在androID节点下加入

1 androID {2       compileOptions {3         sourceCompatibility JavaVersion.VERSION_1_84         targetCompatibility JavaVersion.VERSION_1_85       }6 }

对build.gradle进行build，OK，大功告成；

Lamdba使用

我们在AndroID开发中，经常会使用到大量的监听设置以及异步回调等场景。比如点击事件:

1 textVIEw.setonClickListener(new VIEw.OnClickListener(){2     @OverrIDe3     public voID onClick(VIEw v) {4         Toast.makeText(getApplicationContext(), "hello Lambda", Toast.LENGTH_LONG).show();5     }6 });

这种写法是我们以前最常见的，一个简单的监听事件，需要这么多行代码才能搞定，而且{}中嵌套{}，看起来非常臃肿。匿名类型最大的问题就在于其冗余的语法，有人戏称匿名类型导致了“高度问题”（height problem）：比如前面OnClickListener的例子里的五行代码中仅有一行在做实际工作。lambda表达式是匿名方法，它提供了轻量级的语法，从而解决了匿名内部类带来的“高度问题”。使用Lambda语法来代替匿名的内部类，代码不仅简洁，而且可读性很高：

1 textVIEw.setonClickListener( v -> Toast.makeText(getApplicationContext(), "Lambda", Toast.LENGTH_LONG).show());

 

Lambda表达式语法

lambda表达式通常以(argument)->(body)这样的格式书写。

lambda表达式的语法由参数列表、箭头符号->和函数体组成。函数体既可以是一个表达式，也可以是一个语句块：

表达式：表达式会被执行然后返回执行结果。语句块：语句块中的语句会被依次执行，就像方法中的语句一样

首先列举一个完整的lambda Expression：

1 (int a, int b) -> {2     System.out.println("Performing add operation...");3        return a+b;4 }

一个lambda Expression由三部分组成：

参数：(int a, int b)是这个lambda Expression的参数部分，包括参数类型和参数名

箭头：->

代码块：就是用”{}”包含着的那两句代码。

上面说的是一个完整的lambda表达式，在很多情况下，很多东西是可以省略的。比如说，当系统可以根据上下文自动推断出参数的类型的时候，参数类型是可以省略的。这样的话就可以写成：

lambda表达式中，参数的类型可省略。Java编译器根据表达式的上下文推导出参数的类型。就像上面中vIEw的类型是VIEw。

1 (a, b) -> {2     System.out.println("Performing add operation...");3     return a+b;4 }

系统怎么自动推断出参数类型的呢？这个在下面我们就可以看到。
再比如，如果只有一个参数，而参数的类型又可以自动判断，那么连()也是可以省略的，那么就写成了：

1 a -> {2     System.out.println("Performing add operation...");3     return a+a;4 }

再再比如，如果代码块里面只有一行代码，那么{}也是可以省略的，那么就写成了：

1 a ->2     return a+a;

是的，甚至可以写在同一行

1 a -> return a+a;

让我们更进一步，在这里，return其实也是没必要的。

1 a -> a+a;

很好(Great), 如果没有参数的话，是不是就可以写成呢？：

1 -> a+a

 

很可惜，答案是否定的。如果没有参数，那么前面的()是必须存在的。也就是说，必须写成：

1 ()-> a+a

lambda表达式的结构：

参数可以是零个或多个参数类型可指定，可省略（根据表达式上下文推断）参数包含在圆括号中，用逗号分隔表达式主体可以是零条或多条语句,包含在花括号中表达式主体只有一条语句时,花括号可省略表达式主体有一条以上语句时，表达式的返回类型与代码块的返回类型一致表达式只有一条语句时，表达式的返回类型与该语句的返回类型一致函数式接口（Functional interfaces）

实际上，如果你直接把上面的代码放到你的编辑器里面，你的IDE是会报错的，因为lambda是不能这样使用的。lambda的使用永远要跟一个叫做Functional Interface的东西绑定在一起。什么叫Functional Interface呢？Functional Interface也是Java8 中引入的概念.是的，是为了lambda。我们知道java中的interface，而Functional Interface其实就是一个只定义了一个抽象方法的interface。比如Runnable 这个interface就只有一个run方法，那么它就是一个Functional Interface。

那究竟什么样的接口是函数式接口呢？

函数式接口是只有一个抽象方法的接口。用作表示lambda表达式的类型。

在文章开头，我们使用OnClickListener这个监听接口体验了Lambda表达式，有的同学可能在想，如果有了Lambda表达式以后，是不是所有的接口都能用这么简洁的方式了？比如下面：

 1 EditText editText = (EditText) findVIEwByID(R.ID.editText); 2 editText.addTextChangedListener(new TextWatcher() { 3     @OverrIDe 4     public voID beforeTextChanged(CharSequence s, int start, int count, int after) { 5     } 6  7     @OverrIDe 8     public voID onTextChanged(CharSequence s, int start, int before, int count) { 9     }10 11     @OverrIDe12     public voID afterTextChanged(Editable s) {13     }14 });

TextWatcher这个接口能使用Lambda语法吗？答案是NO，并不是所有的接口都能使用Lambda语法，如果要使用Lambda语法，这个接口必须符合规范，它必须是“函数式接口”。什么是函数式接口？

一个函数式接口是一个能够使用类函数做为参数的类型，一个lambda表达式支持提供这样一个实参。好深奥的样子，举个通俗的栗子，我们设置点击监听是为了在按钮被点击之后执行一段代码，按照普通人的思想，代码应该这样写(伪代码)：

button.set点击监听({点击后需要执行的代码})；

我们应该将｛点击后需要执行的代码｝直接作为参数传入，当然为了体现封装的特性，我们需要将这段代码块封装成方法：

1 button.set点击监听(onClick())；2 3 onClick(){4      点击后需要执行的代码;5 }

我们知道java是面向对象的编程语言，不支持方法作为参数被传入，所以必须用一个接口去封装它，这就是OnClickListener，我们传统的匿名类方式。而Lambda表达式在表面上来看就像是直接将一段代码作为方法参数传入了(本质就是一个匿名的方法)，更像是面向函数的编程语言，为了能够使用这样简洁的编程方式，必须给它定义个规矩，这就是“函数式接口”为什么会出现，它就是规矩，要想使用Lambda表达式，接口必须遵循这个规矩。

那函数式接口到底需要满足怎样的条件？

一个接口，如果只有一个显式声明的抽象方法（可以有其他非抽象方法），那么它就是一个函数接口（之前它们被称为SAM类型，即单抽象方法类型（Single Abstract Method））。函数式接口一般用@Functionalinterface标注出来（也可以不标）。

卧槽，接口怎么能允许有非抽象方法呢？那不是抽象类了吗？但是jdk8中接口就能有非抽象方法，这些方法由default修饰，jdk8在java.util.function包中新增了很多函数式接口，这些接口都只有一个抽象方法，但有多个default修饰的实现方法，这些接口上都有一个@Functionalinterface的注解，表示这是一个函数式接口，加上这个注解之后，编译器就会验证该接口是否满足函数式接口的要求。如果带@Functionalinterface注解的接口定义了两个抽象方法会报语法错误，这也成了检测函数式接口的一种方式。比如下面function包中新增的函数式接口：

 1 /** 2  * 函数式接口 3  * @since 1.8 4  */ 5 @Functionalinterface 6 public interface Function { 7  8     /** 9      * 抽象方法10      */11     R apply(T t);12 13     default Functioncompose(Function<? super V, ? extends T> before) {14         Objects.requireNonNull(before);15         return (V v) -> apply(before.apply(v));16     }17 18     default FunctionandThen(Function<? super R, ? extends V> after) {19         Objects.requireNonNull(after);20         return (T t) -> after.apply(apply(t));21     }22 23     static Function IDentity() {24         return t -> t;25     }26 }

默认方法和静态接口方法：

Java SE 7时代为一个已有的类库增加功能是非常困难的。具体的说，接口在发布之后就已经被定型，除非我们能够一次性更新所有该接口的实现，否则向接口添加方法就会破坏现有的接口实现。默认方法（之前被称为虚拟扩展方法或守护方法）的目标即是解决这个问题，使得接口在发布之后仍能被逐步演化。

默认方法利用面向对象的方式向接口增加新的行为。它是一种新的方法：接口方法可以是抽象的或是默认的。默认方法拥有其默认实现，实现接口的类型通过继承得到该默认实现（如果类型没有覆盖该默认实现）。此外，默认方法不是抽象方法，所以我们可以放心的向函数式接口里增加默认方法，而不用担心函数式接口的单抽象方法限制。

除了默认方法，Java SE 8还在允许在接口中定义静态方法。这使得我们可以从接口直接调用和它相关的辅助方法（Helper method），而不是从其它的类中调用（之前这样的类往往以对应接口的复数命名，例如Collections）。比如，我们一般需要使用静态辅助方法生成实现Comparator的比较器，在Java SE 8中我们可以直接把该静态方法定义在Comparator接口中：

1 public static <T, U extends Comparable<? super U>>2            Comparatorcomparing(Function keyExtractor) {3          return (c1, c2) -> keyExtractor.apply(c1).compareto(keyExtractor.apply(c2));4 }

关于函数式接口，有兴趣的同学可以去了解一下java.util.function这个包中的接口；我就不多说了。关键的是记住一条，Lambda表达式只适用于只有只有一个抽象方法的“函数式接口”。这就是为什么TextWatcher不能使用Lambda表达式（有3个抽象方法）。

Lambda表达式的目标类型以及匹配

我们可以把Lambda表达式当做是一个Object，但它有自己的类型名称叫做“目标类型（target type）”。Lambda表达式的目标类型是“函数接口（functional interface）”，我们不能把Lambda表达式直接赋值给Object，一个Lambda表达式只有在转型成函数接口后才能被当作Object使用。比如：

 1 //可以用一个Lambda表达式为一个函数接口赋值 2 Runnable r1 = () -> {System.out.println("Hello Lambda!");}; 3 //然后再赋值给一个Object 4 Object obj1 = r1; 5  6 //不能这样干  ERROR! Object is not a functional interface! 7 Object obj2 = () -> {System.out.println("Hello Lambda!");}; 8  9 //必须显式的转型成一个函数接口才可以10 Object obj3 = (Runnable) () -> { System.out.println("Hello Lambda!"); };11 12 //Lambda表达式只有在转型成一个函数接口后才能被当做Object使用,所以下面这句也不能编译13 System.out.println( () -> {} ); //错误! 目标类型不明确，println方法可以接受任何类型的参数，而() -> {}能匹配上很多函数接口14 15 //必须先转型16 System.out.println( (Runnable)() -> {} ); // 正确

  一个Lambda表达式可以有多个目标类型（函数式接口），只要函数匹配成功即可，java编译时会自动根据上下文去推断对应的函数接口。但是Lambda表达式必须至少有一个目标类型，要不然就是语法错误。栗子：

如果SDK中有另一个跟OnClickListener一样的函数接口，但是接口名不一样：

1 public interface MyOnClickListener {2     voID onClick(VIEw v);3 }

下面这句代码也是正确的，编译的时候发现setonClickListener方法接受的是OnClickListener类型，而v -> Log.v(TAG, “Lambda”)正好符合onClick(VIEw v)方法，所以java编译器就会自动将其匹配为OnClickListener函数接口，而不是MyOnClickListener。

1 findVIEwByID(R.ID.textVIEw).setonClickListener( v -> Log.v(TAG, "Lambda"));

 

总结

以上是内存溢出为你收集整理的Lambda表达式 For Android全部内容，希望文章能够帮你解决Lambda表达式 For Android所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。