Java8新特性之Lambda表达式的使用

Java8新特性之Lambda表达式的使用

1. lambda表达式介绍

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

public class LambdaTest {

public static void main(String[] args) {

// 使用lambda表达式创建线程

Thread thread = new Thread(() -> {

http:// System.out.println("thread running");

});

thread.start();

}

}

// 运行结果

thread running

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);

}

// 运行结果

声明参数类型

a: 123

不声明参数类型

a: 123

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

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);

}

// 运行结果

定义参数圆括号

a: 123

一个参数可不定义参数圆括号

a: 123

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

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);

}

// 运行结果

使用方法体大括号

a: 123

一个语句可不使用方法体大括号

a: 123

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

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);

}

// 运行结果

声明返回关键字

579

一个表达式返回值语句可不声明返回关键字

579

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);

}

pubhttp://lic 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);

}

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);

}

// 运行结果

1578

4. lambda表达式的优缺点

优点：

1.使代码更加简洁；

2.减少匿名内部类的创建，节省资源；

缺点：

1.可维护性差，必须熟悉抽象方法的参数列表；

2.可读性差，必须对lambda表达式有一定深入；

5. lambda表达式的使用场景

在声明方法时，方法的形参列表包含一个或者多个函数式接口就可jHKLVSS以使用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);

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。