jdk8新特性之Lambda表达式

引言

Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。java8 新特性非常多,我们这篇主要讲述Lambda表达式。
Lambda表达式,也可以称为闭包,它是推动java 8 发布的最重要新特性。
Lambda允许把函数作为一个方法的参数,函数作为参数传递进方法中。

语法

完整的Lambda表达式由三部分组成:参数列表、箭头、声明语句;

1
(Type1 param1, Type2 param2, ..., TypeN paramN) -> { statment1; statment2; ...... return statmentM;}

以下是Lambda表达式的重要特征:

  • 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值。
    (param1,param2, ..., paramN) -> { statment1; statment2; ...... return statmentM;}

  • 可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。
    param1 -> { statment1; statment2; ...... return statmentM;}

  • 可选的大括号:如果主体包含了一个语句,就不需要使用大括号。
    (param1,param2, ..., paramN) -> statment1

  • 可选的返回关键字:如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指明表达式返回了一个数值。
    param1 -> statment1

Lambda 表达式实例

Lambda 表达式的简单例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 1. 不需要参数,返回值为 5
() -> 5

// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x

// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y

// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y

// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

现在我们在java代码中来实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package com.adanblog.demo;

/**
* Lambda表达式例子
* @author adanblog
*/
public class LambdaTest {
public static void main(String[] args) {
// 1. 不需要参数,返回值为 5,() -> 5
Fun1 f=()->5;
System.out.println("返回5:"+f.test());

// 2. 接收一个参数(数字类型),返回其2倍的值
Fun2 f2=x -> 2 * x;
System.out.println("5 * 2 = "+f2.test(5));

// 3. 接受2个参数(数字),并返回他们的差值
Fun3 f3=(x, y) -> x - y;
System.out.println("5 - 3 = "+f3.test(5,3));

// 4. 接收2个int型整数,返回他们的和
Fun4 f4=(int x, int y) -> x + y;
System.out.println("5 + 3 = "+f4.test(5,3));

// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
Fun5 f5=(String s) -> System.out.print(s);
f5.test("我们是来参数lamdba");
}

interface Fun1 {
int test();
}

interface Fun2 {
int test(int a);
}

interface Fun3 {
int test(int a,int b);
}

interface Fun4 {
int test(int a,int b);
}

interface Fun5 {
void test(String str);
}
}

执行main方法后打印:

1
2
3
4
5
返回5:5
5 * 2 = 10
5 - 3 = 2
5 + 3 = 8
我们是来参数lamdba

变量作用域

Lambda表达式只能引用标记了final的外层局部变量,这就是说不能在lambda内部修改定义在域外的局部变量,否则会编译称为。
代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.adanblog.demo;

/**
* Lambda表达式变量作用域例子
* @author adanblog
*/
public class LambdaTest2 {
final static String salutation = "Hello! ";
public static void main(String[] args) {
GreetingService gs=(mes)->System.out.println(salutation+mes);
gs.sayMessage("我是Lambda的测试!");
}

interface GreetingService {
void sayMessage(String message);
}
}

运行输出:

1
Hello! 我是Lambda的测试!

我们也可以直接在lamdba表达式中访问外层的局部变量:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.adanblog.demo;

/**
* Lambda表达式变量作用域例子
* @author adanblog
*
*/
public class LambdaTest3 {
public static void main(String[] args) {
int num=2;
Fun c=(par)->System.out.println(String.valueOf(num+par));
c.test(5);//输出结果为7
}

interface Fun{
void test(int i);
}
}

Lambda 表达式的局部变量可以不用声明为 final,但是必须不可被后面的代码修改(即隐性的具有 final 的语义)
在上面例子中,更改变量num的值就会报错

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.adanblog.demo;

/**
* Lambda表达式变量作用域例子
* @author adanblog
*
*/
public class LambdaTest3 {
public static void main(String[] args) {
int num=2;
Fun c=(par)->System.out.println(String.valueOf(num+par));
c.test(5);//输出结果为7
//在这里更改变量值,编译就会报错:Local variable num defined in an enclosing scope must be final or effectively final
num=5;
}

interface Fun{
void test(int i);
}
}

在lambda表达式当中,不允许声明一个与局部变量同名的参数或者局部变量。

1
2
int num=2;
Fun c=(num)->System.out.println(String.valueOf(num));//编译报错
-------------本文结束感谢您的阅读-------------