Java8---Lambda表达式

Lambda 表达式

lambda表达式（也称为闭包），它允许我们将函数当成参数传递给某个方法，或者把代码本身当作数据处理。

lambda表达式可以看成是匿名内部类，使用时，接口必须是函数式接口(有且仅有一个抽象方法的接口，接口中方法默认被 public abstract 修饰)。

基本语法：

   <函数式接口>  <变量名> = (参数1，参数2...) -> {
                    //方法体
        }

说明：
(参数1，参数2…)表示参数列表；->表示连接符；{ }内部是方法体，最简单的Lambda表达式可以由 用逗号分隔的参数列表、->符号和语句块组成。

1、=右边的类型会根据左边的函数式接口类型自动推断；
2、如果参数列表为空，只需保留()；
3、如果参数只有1个，()可以省略，只需要参数的名称即可；
4、如果执行语句只有1句，且无返回值，{ }可以省略，若有返回值，则若想省去{}，则必须同时省略return，且执行语句也保证只有1句；
5、参数列表的数据类型会自动推断；
6、lambda不会生成一个单独的内部类文件；
7、lambda表达式若访问了局部变量，则局部变量必须是final的，若是局部变量没有加final关键字，系统会自动添加，此后在修改该局部变量，会报错；

局部变量修改报错如图：

 

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

示例代码：

public interface LambdaTest {
    abstract void print();
}

public interface LambdaTest2 {
    abstract void print(String a);
}

public interface DefalutTest {
    static int a =5;
    default void defaultMethod(){
        System.out.println("DefalutTest defalut 方法");
    }

    int sub(int a,int b);

    static void staticMethod() {
        System.out.println("DefalutTest static 方法");
    }
}

public class Main {

    public static void main(String[] args) {
        //匿名内部类--java8之前的实现方式
        DefalutTest dt = new DefalutTest(){
            @Override
            public int sub(int a, int b) {
                // TODO Auto-generated method stub
                return a-b;
            }
        };

        //lambda表达式--实现方式1
        DefalutTest dt2 =(a,b)->{
            return a-b;
        };
        System.out.println(dt2.sub(2, 1));

        //lambda表达式--实现方式2，省略花括号
        DefalutTest dt3 =(a,b)->a-b;
        System.out.println(dt3.sub(5, 6));

        //测试final
        int c = 5;
        DefalutTest dt4 =(a,b)->a-c;
        System.out.println(dt4.sub(5, 6));

        //无参方法，并且执行语句只有1条
        LambdaTest lt = ()-> System.out.println("测试无参");
        lt.print();
        //只有一个参数方法
        LambdaTest2 lt1 = s-> System.out.println(s);
        lt1.print("有一个参数");
    }
}

 

2、Lambda的形式

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

2.1、 无参带返回值

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

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

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

以上的Lambda等价于：

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

2.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都省了。

2.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表达式，其中省略掉了每一个参数的类型，编译器自动推断。多条语句时实现体的{}不能省。

 

3、Lambda作为参数

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

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

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

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

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

3.1、定义接口

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

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

3.2、定义方法接收参数

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

// 无参
public static void testLambda(LambdaInterface1 lam1){
    lam1.printString();
}
​
// 带参
public static void testLambda2(String s,LambdaInterface2 lam2){
    lam2.printString(s);
}

3.3、Lambda实现

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

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

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

 

4、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时就变成了我们自己对每一个元素的处理了。我们只负责处理即可。

 

5、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

 

6、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);
}

 

今天关于Java8新特性-Lambda表达式就讲到这里了，接下来我会继续讲述Java8新特性之函数式接口。敬请继续关注！欢迎留言评论。