Java8中你可能不知道的一些地方之Lambda

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

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

匿名内部类，即一个没有名字的，存在于一个类或方法内部的类。当咱们须要用某个类且只须要用一次，建立和使用合二为一时，咱们能够选择匿名内部类，省掉咱们定义类的步骤。

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

测试类中调用方法

package com.lotbyte.main;
/*
   定义和使用匿名内部类
*/
public class NoNameClass {
   public static void main(String[] args) {

       Model m = new Model(){
           @Override
           public void func() {
               System.out.println("方法的实现");
          }
      };
       m.func();
  }
}
// 须要被实现的接口
interface Model{
   void func();
}

2、Lambda快速使用

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

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

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

public class NonameClassForLambda {
   public static void main(String[] args) {
       // Lambda方式简写，方法实现能够很简单
       Model1 md = ()-> System.out.println("hello");
       md.func();
       
       // 也能够是比较复杂的操做
       md = () -> {
           for (int i = 1; i <=5; i++) {
               System.out.println(i);
          }
      };
       md.func();
  }
}
// 接口
interface Model1{
   void func();
}

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

注意：Lambda中必须有个接口

3、Lambda的形式

使用 Lambda 时，实现方法能够有参数，也能够有返回值，若是没指定参数类型，则由编译器自行推断得出。

3.一、 无参带返回值

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

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

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

以上的 Lambda 等价于：

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

3.2 、带参带返回值

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

interface Model3{
   String func(int a);
}
Model3 md3 = (int a) -> {
   return "This is a number " + a;
};

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

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

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

3.3 、带多个参数

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

interface Model4{
   String func(int a, int b, String oper);
}
Model4 md4 = (a, b, s) -> {
     String res = "";
     if("+".equals(s)){
           res = ( a+b ) + "";
    }else if("-".equals(s)){
           res = ( a-b ) + "";
    }else if("*".equals(s)){
           res = ( a*b ) + "";
    }else if("/".equals(s)){
           res = ( a/b ) + ""; // 暂不考虑除0的状况
    }else{
           res =  "操做有失误";
    }
     return res;
};
System.out.println(md4.func(1,1,"+"));

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

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

4、Lambda做为参数

在 jdk8 以前，接口能够做为方法参数传入，执行时必须提供接口实现类的实例。从 java8 开始，Lambda 能够做为接口方法实现，看成参数传入，不管从形式上仍是实际上都省去了对象的建立。使代码更加的紧凑简单高效。

使用 Lambda 表达式须要有如下几步：

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

二、在某方法中须要接口做为参数；

三、调用方法时须要将抽象方法实现（此时咱们使用 Lambda 表达式）并传入便可。

4.一、定义接口

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

// 无参无返回值的方法
interface LambdaInterface1{
   void printString();
}
// 带参无返回值的方法
interface  LambdaInterface2{
   void printString(String str);
}

4.二、定义方法接收参数

在某方法中须要使用接口做为参数

// 无参
public static void testLambda(LambdaInterface1 lam1){
   lam1.printString();
}

// 带参
public static void testLambda2(String s,LambdaInterface2 lam2){
   lam2.printString(s);
}

4.三、Lambda实现

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

// 无参Lambda做为参数
testLambda(()->{
   System.out.println("能够简单，能够复杂");
});
// 带参Lambda做为参数
testLambdaParam("hello",(a)->{
   System.out.println(a);
});

经过以上三步，可以完整地展现 Lambda 如何演变而来。此后在使用时，jdk 中已经提供不少场景了，即前两部已经完成，咱们更多的是实现第三步便可。

5、forEach展现Lambda

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

public static void main(String[] args) {
   List<String> strs = new ArrayList<String>(){
      {
           add("aaa");
           add("bbb");
           add("ccc");
      }
  };
   strs.forEach((str)-> System.out.println(str));
}

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

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

经过在 forEach 方法中调用 Consumer 的 accept 方法，并将每个元素做为参数传入，使得 accept 方法能够对每个元素进行操做，当咱们使用 Lambda 实现 accept 时就变成了咱们本身对每个元素的处理了。咱们只负责处理便可。

6、Lambda中使用变量

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

public static void main(String[] args) {
   List<String> strs = new ArrayList<String>(){
      {
           add("aaa");
           add("bbb");
           add("ccc");
      }
  };
   int j = 1;
   strs.forEach((str)->{
       int i = 0;
       System.out.println(str + " " + i + " " + j);
  });
}

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

7、Lambda做为方法返回值

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

public class Demo004_2 {
   public static void main(String[] args) {
       System.out.println(testLambda().isEmpty("string"));
  }

   // 判断字符串是否为空
   public static AssertEmpty testLambda(){
       return (n)-> null==n||n.trim().isEmpty(n);
  }
}

interface AssertEmpty{
   boolean isEmpty(String str);
}