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));//编译报错
-------------本文结束感谢您的阅读-------------