Lambda表达式-使用说明


 jdk8已经发布4年,其中有一个特性:Lambda,它是一个令开发者便捷开发的一种方式,Lambda Expression (Lambda表达式)是为了让java提供一种面向函数编程,原本在jdk8之前只支持面向对象编程,

而函数式编程则是对行为的抽象(将行为作为一个参数进行传递),接下来通过例子来说明:

这是一个线程对象,传入匿名内部类的例子:

1
2
3
4
5
6
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello World!");
}
});

IDEA会给出提示可以使用Lambda表达式替换。
通过使用Lambda表达式则只需要使用一句话就可代替上面使用匿名类的方式。

1
new Thread(() -> System.out.println("Hello World!"));

在这个例子中,传统的语法规则,我们是将一个匿名内部类作为参数进行传递,我们实现了Runnable接口,并将其作为参数传递给Thread类,这实际上我们传递的是一段代码,也即我们将代码作为了数据进行传递,这就带来许多不必要的“样板代码”。

Lambda表达式一共有三部分组成:()->{}, 左边()代表参数,中间->代表传递,右边{}代表函数主体
  
后面的示例中我们会详解这个结构,包括有无参数,有无返回值的问题。 那么这个看起来奇奇怪怪的不太像Java的语法规则,其本身含义到底什么呢?这也是开始困扰我的问题,什么时候在什么场景下可以使用Lambda表达式。

  能够接收Lambda表达式的参数类型,是一个只包含一个方法的接口。只包含一个方法的接口称之为“函数接口”。

  例如上面创建一个线程的示例,Runnable接口只包含一个方法,所以它被称为“函数接口”,所以它可以使用Lambad表达式来代替匿名内部类。根据这个规则,我们试着来写一个函数接口,并使用Lambda表达式作为参数传递。 
  
  

1
2
3
4
5
6
7
8
9
package com.coderbuff.custom;

/**
* 函数接口:只有一个方法的接口。作为Lambda表达式的类型
* Created by Kevin on 2018/2/17.
*/
public interface FunctionInterface {
void test();
}

测试:

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
package com.coderbuff.custom;

import org.junit.Test;

/**
* 函数接口测试
* Created by Kevin on 2018/2/17.
*/
public class FunctionInterfaceTest {

@Test
public void testLambda() {
func(new FunctionInterface() {
@Override
public void test() {
System.out.println("Hello World!");
}
});
//使用Lambda表达式代替上面的匿名内部类
func(() -> System.out.println("Hello World"));
}

private void func(FunctionInterface functionInterface) {
functionInterface.test();
}
}

可以看到,只要是一个接口中只包含一个方法,则可以使用Lambda表达式,这样的接口称之为“函数接口”。

  上面的函数接口比较简单不包含参数,也不包含返回值

  我们再来修改FunctionInterface函数接口逐步加大Lambda表达式的难度——包含参数,不包含返回值
  
  

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

import org.junit.Test;

/**
* 函数接口测试
* Created by Kevin on 2018/2/17.
*/
public class FunctionInterfaceTest {

@Test
public void testLambda() {
//使用Lambda表达式代替匿名内部类
func((x) -> System.out.println("Hello World" + x));
}

private void func(FunctionInterface functionInterface) {
int x = 1;
functionInterface.test(x);
}
}

关注Lambda表达式“(x) -> Sysout.out.println(“Hello World” + x)”,左边传递的是参数,此处并没有指明参数类型,因为它可以通过上下文进行类型推导,但在有些情况下不能推导出参数类型(在编译时不能推导通常IDE会提示),此时则需要指明参数类型。我个人建议,任何情况下指明函数的参数类型。

  哪种情况不能推导出参数类型呢?就是函数接口是一个泛型的时候。
  

1
2
3
4
5
6
7
8
9
package com.coderbuff.custom;

/**
* 函数接口:只有一个方法的接口。作为Lambda表达式的类型
* Created by Kevin on 2018/2/17.
*/
public interface FunctionInterface<T> {
void test(T param);
}

 测试:
 

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

import org.junit.Test;

/**
* 函数接口测试
* Created by Kevin on 2018/2/17.
*/
public class FunctionInterfaceTest {

@Test
public void testLambda() {
//使用Lambda表达式代替匿名内部类
func((Integer x) -> System.out.println("Hello World" + x));
}

private void func(FunctionInterface<Integer> functionInterface) {
int x = 1;
functionInterface.test(x);
}
}

 上面的示例提到了Lambda表达式的两种情况:

  无参数,无返回值

  有参数,无返回值

  接下来就是有参数,有返回值这种较为复杂的情况。
  

1
2
3
4
5
6
7
8
9
package com.coderbuff.custom;

/**
* 函数接口:只有一个方法的接口。作为Lambda表达式的类型
* Created by Kevin on 2018/2/17.
*/
public interface FunctionInterface<T> {
boolean test(T param);
}

 测试:
 

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

import org.junit.Test;

/**
* 函数接口测试
* Created by Kevin on 2018/2/17.
*/
public class FunctionInterfaceTest {

@Test
public void testLambda() {
//使用Lambda表达式代替匿名内部类
func((Integer x) -> true);
}

private void func(FunctionInterface<Integer> functionInterface) {
int x = 1;
functionInterface.test(x);
}
}

此时的Lambda表达式“(Integer x) -> true”,右边是表达式的主体,直接返回true,如果有多行代码,则可以直接使用花括号表示,例如:

1
2
3
4
func((Integer x) -> {
System.out.println("Hello World" + x);
return true;
});

Lambda表达式基本的语法规则:

  无参数,无返回值

  有参数,无返回值

  有参数,有返回值

  这三种基本情况已经大致清楚了,特别是需要弄清,什么时候可以使用Lambda表达式代替匿名内部类,也就是Lambda表达式的应用场景是函数接口。Lambda表达式这一新特性在JDK8中的引入,更大的好处则是集合API的更新,新增的Stream类库,使得我们在遍历使用集合时不再像以往那样不断地使用for循环。

JDK8使用集合的正确姿势

  示例:计算来自“chengdu”的学生数量有多少。

  在JDK8前的代码:

1
2
3
4
5
for (Student student : studentList) {
if (student.getCity().equals("chengdu")) {
count++;
}
}

JDK8使用集合的正确姿势:

1
count = studentList.stream().filter((student -> student.getCity().equals("chengdu"))).count();

API的使用“难度”恰似提高了,实际只是不熟悉而已。传统迭代的方式需要阅读完整个循环才能明白代码逻辑,JDK8通过流的方式则可以望文生义且代码量大大减小。

  其中最为重要的是——Stream流。Stream的是通过函数式编程方式实现的在集合类上进行复杂操作的工具。若要详细讲解Stream的实现方式我相信再写一篇博客也不为过,所以此处不再考查Stream的内部实现。这里是想告诉大家,如果有幸使用JDK8的开发环境进行开发,尽量学习使用新的集合操作API。

 有关Lambda表达式的应用太多,并发编程、响应式编程等等。

本文引用:http://www.cnblogs.com/yulinfeng/p/8452379.html

-------------本文结束感谢您的阅读-------------
0%