Java8新特性之Lambda表达式（一）

Java8新特性之Lambda表达式（一）

文章目录

1. lambda表达式介绍

lambda表达式是Java8提供的新特性之一，也可以称之为闭包；它支持Java能够进行简单的函数式编程，也就是说可以把一个匿名函数作为一个方法的参数进行传递；其格式分为三部分，第一部分为入参列表，第二部由->固定组成，第三部分为方法体；

public class LambdaTest {
 
    public static void main(String[] args) {
        // 使用lambda表达式创建线程
        Thread thread = new Thread(() -> {
            System.out.println("thread running");
        });
        thread.start();
    }
}
12345678910
// 运行结果
thread running
12

2. lambda表达式的重要特征

  • 可选的参数类型声明：不需要声明参数的类型，编译器可以统一识别参数值；

    		public class LambdaTest {
    		 
    		    private Integer a;
    		 
    		    public LambdaTest(Integer a) {
    		        this.a = a;
    		    }
    		 
    		    public void print(LambdaInterface lambdaInterface) {
    		        lambdaInterface.print(this.a);
    		    }
    		 
    		    public static void main(String[] args) {
    		        LambdaTest lambdaTest = new LambdaTest(123);
    		        // 声明参数类型
    		        System.out.println("声明参数类型");
    		        lambdaTest.print((Integer a) -> {
    		            System.out.println("a: " + a);
    		        });
    		        // 不声明参数类型
    		        System.out.println("不声明参数类型");
    		        lambdaTest.print((a) -> {
    		            System.out.println("a: " + a);
    		        });
    		    }
    		}
    		 
    		interface LambdaInterface {
    		    void print(Integer a);
    		}
    		123456789101112131415161718192021222324252627282930
    		// 运行结果
    		声明参数类型
    		a: 123
    		不声明参数类型
    		a: 123
    		12345

  • 可选的参数圆括号：一个参数时不需要定义圆括号，但没有参数或者多个参数时则必须要定义；

    		public class LambdaTest {
    		 
    		    private Integer a;
    		 
    		    public LambdaTest(Integer a) {
    		        this.a = a;
    		    }
    		 
    		    public void print(LambdaInterface lambdaInterface) {
    		        lambdaInterface.print(this.a);
    		    }
    		 
    		    public static void main(String[] args) {
    		        LambdaTest lambdaTest = new LambdaTest(123);
    		        // 定义参数圆括号
    		        System.out.println("定义参数圆括号");
    		        lambdaTest.print((a) -> {
    		            System.out.println("a: " + a);
    		        });
    		        // 一个参数可不定义参数圆括号
    		        System.out.println("一个参数可不定义参数圆括号");
    		        lambdaTest.print(a -> {
    		            System.out.println("a: " + a);
    		        });
    		    }
    		}
    		 
    		interface LambdaInterface {
    		    void print(Integer a);
    		}
    		123456789101112131415161718192021222324252627282930
    		// 运行结果
    		定义参数圆括号
    		a: 123
    		一个参数可不定义参数圆括号
    		a: 123
    		12345

  • 可选的大括号：如果方法体仅有一个语句，可不需要使用大括号；

    		public class LambdaTest {
    		 
    		    private Integer a;
    		 
    		    public LambdaTest(Integer a) {
    		        this.a = a;
    		    }
    		 
    		    public void print(LambdaInterface lambdaInterface) {
    		        lambdaInterface.print(this.a);
    		    }
    		 
    		    public static void main(String[] args) {
    		        LambdaTest lambdaTest = new LambdaTest(123);
    		        // 使用方法体大括号
    		        System.out.println("使用方法体大括号");
    		        lambdaTest.print(a -> {
    		            System.out.println("a: " + a);
    		        });
    		        // 一个语句可不使用方法体大括号
    		        System.out.println("一个语句可不使用方法体大括号");
    		        lambdaTest.print(a -> System.out.println("a: " + a));
    		    }
    		}
    		 
    		interface LambdaInterface {
    		    void print(Integer a);
    		}
    		12345678910111213141516171819202122232425262728
    		// 运行结果
    		使用方法体大括号
    		a: 123
    		一个语句可不使用方法体大括号
    		a: 123
    		12345

  • 可选的返回关键字：如果方法体仅有一个表达式返回值语句，可不需要声明返回关键字，但存在大括号时则必须声明；

    		public class LambdaTest {
    		 
    		    private Integer a;
    		    private Integer b;
    		 
    		    public LambdaTest(Integer a, Integer b) {
    		        this.a = a;
    		        this.b = b;
    		    }
    		 
    		    public Integer sum(LambdaInterface lambdaInterface) {
    		        return lambdaInterface.calculate(this.a, this.b);
    		    }
    		 
    		    public static void main(String[] args) {
    		        LambdaTest lambdaTest = new LambdaTest(123, 456);
    		        // 声明返回关键字
    		        System.out.println("声明返回关键字");
    		        Integer s1 = lambdaTest.sum((Integer a, Integer b) -> {
    		            return a + b;
    		        });
    		        System.out.println(s1);
    		        // 一个表达式返回值语句可不声明返回关键字
    		        System.out.println("一个表达式返回值语句可不声明返回关键字");
    		        Integer s2 = lambdaTest.sum((a, b) -> a + b);
    		        System.out.println(s2);
    		    }
    		}
    		 
    		interface LambdaInterface {
    		    Integer calculate(Integer a, Integer b);
    		}
    		1234567891011121314151617181920212223242526272829303132
    		// 运行结果
    		声明返回关键字
    		579
    		一个表达式返回值语句可不声明返回关键字
    		579
    		12345

3. lambda表达式对域外变量的限制

lambda表达式对域外的局部变量具有隐性final语义的限制，但对成员变量没有该限制；

public class LambdaTest {
 
    private Integer a;
    private Integer b;
 
    public LambdaTest(Integer a, Integer b) {
        this.a = a;
        this.b = b;
    }
 
    public Integer sum(LambdaInterface lambdaInterface) {
        return lambdaInterface.calculate(this.a, this.b);
    }
 
    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest(123, 456);
        int c = 111;
        Integer s1 = lambdaTest.sum((a, b) -> {
            // 修改域外局部变量将出现编译错误
            c = 222;
            return a + b;
        });
        System.out.println(s1);
 
        int d = 333;
        Integer s2 = lambdaTest.sum((a, b) -> {
            // 域外修改lambda表达式内部使用过的域外局部变量也将导致编译错误
            return a + b + d;
        });
        d = 444;
        System.out.println(s2);
    }
}
 
interface LambdaInterface {
    Integer calculate(Integer a, Integer b);
}
12345678910111213141516171819202122232425262728293031323334353637
public class LambdaTest {
 
    private Integer a;
    private Integer b;
    private Integer c;
 
    public LambdaTest(Integer a, Integer b, Integer c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
 
    public Integer sum(LambdaInterface lambdaInterface) {
        return lambdaInterface.calculate(this.a, this.b);
    }
 
    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest(123, 456, 789);
        Integer s1 = lambdaTest.sum((a, b) -> {
            // 没有出现编译错误
            lambdaTest.c = 999;
            return a + b + lambdaTest.c;
        });
        System.out.println(s1);
    }
}
 
interface LambdaInterface {
    Integer calculate(Integer a, Integer b);
}
123456789101112131415161718192021222324252627282930
// 运行结果
1578
12

4. lambda表达式的优缺点

优点：

  1. 使代码更加简洁；
  2. 减少匿名内部类的创建，节省资源；

缺点：

  1. 可维护性差，必须熟悉抽象方法的参数列表；
  2. 可读性差，必须对lambda表达式有一定深入；

5. lambda表达式的使用场景

在声明方法时，方法的形参列表包含一个或者多个函数式接口就可以使用lambda表达式；如：

使用实现Runnable接口创建线程

使用实现Callable接口创建FutureTask

使用四大函数式接口消费者接口Consumer、提供者接口Supplier、断言型接口Predicate、函数型接口Function

6. lambda表达式的实现原理

lambda表达式是通过特定的语法，让编译器对java文件进行编译时，针对每一个lambda表达式会编译成一个对应的静态方法，由此也可证明lambda表达式并不是一种语法糖；

// 对上面的LambdaTest.java编译后的LambdaTest.class文件使用javap -p进行查看将会得到如下结果
javap -p LambdaTest.class
Compiled from "LambdaTest.java"
public class cn.jackiegu.java8.study.lambda.LambdaTest {
  private java.lang.Integer a;
  private java.lang.Integer b;
  private java.lang.Integer c;
  public cn.jackiegu.java8.study.lambda.LambdaTest(java.lang.Integer, java.lang.Integer, java.lang.Integer);
  public java.lang.Integer sum(cn.jackiegu.java8.study.lambda.LambdaInterface);
  public static void main(java.lang.String[]);
  private static java.lang.Integer lambda$main$0(cn.jackiegu.java8.study.lambda.LambdaTest, java.lang.Integer, java.lang.Integer);
}
 
123456789101112

来源：https://blog.csdn.net/gu19930914/article/details/115694182

posted @   Lafite-1820  阅读(14)  评论(0)  编辑  收藏  举报
相关博文：
· Java8新特性之函数式接口（二）
· Java8新特性之方法引用（三）
· Java8 新特性：Lambda 表达式
· Java8新特性-Lambda表达式
· Java8新特性: lambda 表达式介绍
阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）
点击右上角即可分享
微信分享提示