Java8新特征之Lambda

Lambda表达式（也称为闭包），它允许我们将函数当成参数传递给某个方法，或者把代码本身当作数据处理。很多语言（Groovy、Scala等）从设计之初就支持Lambda表达式。但是java中使用的是匿名内部类代替。最后借助强大的社区力量，找了一个折中的Lambda实现方案，可以实现简洁而紧凑的语言结构。

1、匿名内部类到Lambda的演化

​ 匿名内部类，即一个没有名字的，存在于一个类或方法内部的类。当我们需要用某个类且只需要用一次，创建和使用和二为一时，我们可以选择匿名内部类，省掉我们定义类的步骤。

​ 匿名内部类会隐士的继承一个类或实现一个接口，或者说匿名内部类是一个继承了该类或者实现了该接口的子类匿名对象。下面看一个匿名内部类的例子：

测试类中调用方法

1package com.lotbyte.main;
2/*
3   定义和使用匿名内部类
4*/
5public class NoNameClass {
6   public static void main(String[] args) {
7
8       Model m = new Model(){
9           @Override
10           public void func() {
11               System.out.println("方法的实现");
12          }
13      };
14       m.func();
15  }
16}
17// 需要被实现的接口
18interface Model{
19   void func();
20}

2、Lambda快速使用

​ 从某种意义上来说，Lambda表达式可以看作是匿名内部类对象的简写形式。最简单的Lambda表达式可以由 用逗号分隔的参数列表、->符号和语句块组成。

注意：此时匿名内部类只能实现接口，不能是继承抽象类

例如将上面的例子做一个简化，使用Lambda的形式如下：

1public class NonameClassForLambda {
2   public static void main(String[] args) {
3       // Lambda方式简写，方法实现可以很简单
4       Model1 md = ()-> System.out.println("hello");
5       md.func();
6
7       // 也可以是比较复杂的操作
8       md = () -> {
9           for (int i = 1; i <=5; i++) {
10               System.out.println(i);
11          }
12      };
13       md.func();
14  }
15}
16// 接口
17interface Model1{
18   void func();
19}

​ 以上是一个简单的Lambda的书写形式，()中是形参列表，没有则为空括号， ->为语法格式，之后则为方法的实现（一条语句可以直接书写，当有多条语句时，需要使用{}进行包裹）。从这可以看出在接口中必须只能存在一个抽象方法。

注意：Lambda中必须有个接口

3、Lambda的形式

​ 使用Lambda时，实现方法可以有参数，也可以有返回值，如果没指定参数类型，则由编译器自行推断得出。

3.1、 无参带返回值

生成[1,10]之间的任意整数

1interface Model2{
2   int func();
3}
4Model2 md2 = () -> {return (int)(Math.random()*10+1)};

说明：Lambda的改写需要有对应的抽象方法，当没有参数时需要使用()占位，当表达式只有一行代码时，可以省略return和{}

以上的Lambda等价于：

Model2 md2 = () -> (int)(Math.random()*10+1);

3.2 、带参带返回值

返回一个对数字描述的字符串

1interface Model3{
2   String func(int a);
3}
4Model3 md3 = (int a) -> {
5   return "This is a number " + a;
6};

说明：形参写在()内即可，参数的类型可以省略，此时将由编译器自行推断得出，同时还可以省略()

md3 =  a -> "This is a number " + a;

省略了参数类型，小括号，同时连带实现体的括号和return都省了。

3.3 、带多个参数

根据输入的运算符计算两个数的运算，并返回结果

1interface Model4{
2   String func(int a, int b, String oper);
3}
4Model4 md4 = (a, b, s) -> {
5     String res = "";
6     if("+".equals(s)){
7           res = ( a+b ) + "";
8    }else if("-".equals(s)){
9           res = ( a-b ) + "";
10    }else if("*".equals(s)){
11           res = ( a*b ) + "";
12    }else if("/".equals(s)){
13           res = ( a/b ) + ""; // 暂不考虑除0的情况
14    }else{
15           res =  "操作有失误";
16    }
17     return res;
18};
19System.out.println(md4.func(1,1,"+"));

以上例子为多个参数的Lambda表达式，其中省略掉了每一个参数的类型，编译器自动推断。多条语句时实现体的{}不能省。

最新技术学习资料(^_^) → lezijie007（程序员暗号：513cto13）

4、Lambda作为参数

​ 在jdk8之前，接口可以作为方法参数传入，执行时必须提供接口实现类的实例。从java8开始，Lambda可以作为接口方法实现，当作参数传入，无论从形式上还是实际上都省去了对象的创建。使代码更加的紧凑简单高效。

使用Lambda表达式需要有以下几步：

​ 1、定义接口，抽象方法的模板；

​ 2、在某方法中需要接口作为参数；

​ 3、调用方法时需要将抽象方法实现（此时我们使用Lambda表达式）并传入即可。

4.1、定义接口

在接口中，必须有且仅有一个抽象方法，以确定Lambda模板

1// 无参无返回值的方法
2interface LambdaInterface1{
3   void printString();
4}
5// 带参无返回值的方法
6interface  LambdaInterface2{
7   void printString(String str);
8}

4.2、定义方法接收参数

在某方法中需要使用接口作为参数

1// 无参
2public static void testLambda(LambdaInterface1 lam1){
3   lam1.printString();
4}
5
6// 带参
7public static void testLambda2(String s,LambdaInterface2 lam2){
8   lam2.printString(s);
9}

4.3、Lambda实现

使用方法时需要用Lambda将抽象方法实现

1// 无参Lambda作为参数
2testLambda(()->{
3   System.out.println("可以简单，可以复杂");
4});
5// 带参Lambda作为参数
6testLambdaParam("hello",(a)->{
7   System.out.println(a);
8});

​ 通过以上三步，能够完整地展示Lambda从和演变而来。此后在使用时，jdk中已经提供很多场景了，即前两部已经完成，我们更多的是实现第三步即可。

5、forEach展示Lambda

例如以ArrayList的遍历为例子，分析Lambda的使用方式。

1public static void main(String[] args) {
2   List<String> strs = new ArrayList<String>(){
3      {
4           add("aaa");
5           add("bbb");
6           add("ccc");
7      }
8  };
9   strs.forEach((str)-> System.out.println(str));
10}

下面看看forEach的源码，定义中使用了接口Consumer作为参数，并调用了其方法：

Consumer

中的抽象方法只有accept一个：

​ 通过在forEach方法中调用Consumer的accept方法，并将每一个元素作为参数传入，使得accept方法可以对每一个元素进行操作，当我们使用Lambda实现accept时就变成了我们自己对每一个元素的处理了。我们只负责处理即可。

6、Lambda中使用变量

​ 在Lambda中可以定义自己的局部变量，也可以使用外层方法的局部变量，还可以使用属性。这一点也不难理解，既然是一个方法的实现，只写了一个代码块，那么使用本身所属方法的局部变量和类的属性也并不过分。

1public static void main(String[] args) {
2   List<String> strs = new ArrayList<String>(){
3      {
4           add("aaa");
5           add("bbb");
6           add("ccc");
7      }
8  };
9   int j = 1;
10   strs.forEach((str)->{
11       int i = 0;
12       System.out.println(str + " " + i + " " + j);
13  });
14}

注意：此时外部局部变量将自动变为final

7、Lambda作为方法返回值

例子：返回判断字符串是否为空

1public class Demo004_2 {
2   public static void main(String[] args) {
3       System.out.println(testLambda().isEmpty("string"));
4  }
5
6   // 判断字符串是否为空
7   public static AssertEmpty testLambda(){
8       return (n)-> null==n||n.trim().isEmpty(n);
9  }
10}
11
12interface AssertEmpty{
13   boolean isEmpty(String str);
14}