再也无需前思后想，一切岂非已然过往。——《且听风吟》
高手问答第 305 期 —— 如何使用 lambda 表达式提升开发效率？
Java8的一个大亮点是引入Lambda表达式，使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时，也会随之被编译成一个函数式接口。
Lambda表达式
https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html
简单来说：就是把我们的函数(方法)作为参数传递、调用等
例子：自定义函数式接口（用jdk自带的函数式接口也可以）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| import java.io.Serializable;
@FunctionalInterface
public interface Func<T, R> extends Serializable {
R apply(T t);
}
|
我们定义一个类可以去实现该接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class FuncImpl implements Func<Object, String> {
@Override
public String apply(Object o) {
return o.toString();
}
}
|
到此为止，都非常的简单
这里就有个问题：假设我有很多的地方需要不同的类去实现Func，我就得每次都去写这么一个类，然后实现该接口并重写方法
这样很麻烦！因此我们使用匿名内部类
1
2
3
4
5
6
7
8
9
10
11
12
| Func<String, Integer> func = new Func<String, Integer>() {
@Override
public Integer apply(String s) {
return s.hashCode();
}
};
|
我们可以看到，使用了匿名内部类后不用每次去新建这个类了，只需要在调用的地方，new一下接口，创建一个匿名内部类即可
但这样还有个问题，我们每次都要写这么一大几行代码，特别麻烦
由此而生，我们有了lambda这种简写的形式
https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#syntax
1
2
3
| Func<String, String> func1 = (String s) -> {
return s.toUpperCase();
};
|
如果只有一行，我们可以省略掉中括号以及return
1
| Func<String, String> func2 = (String s) -> s.toUpperCase();
|
我们可以省略掉后边的参数类型
1
| Func<String, String> func3 = s -> s.toUpperCase();
|
如果我们满足特定的形式，我们还可以使用方法引用（双冒号）的形式缩写
1
| Func<String, String> func4 = String::toUpperCase;
|
这里除了我们的参数->返回值写法：s->s.toUpperCase()，还有很多种
例如无参数带返回值写法()->"yes"、无参无返回值写法()->{}等等
而方法引用这种写法有如下几种：
https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html
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
| package org.dromara.streamquery;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Supplier;
public class MethodReferences {
public static Object staticSupplier() {
return "whatever";
}
public Object instanceSupplier() {
return "whatever";
}
public Object anonymousInstanceFunction() {
return "whatever";
}
public static void main(String[] args) {
Supplier<MethodReferences> conSup = () -> new MethodReferences();
conSup = MethodReferences::new;
IntFunction<int[]> intFunction = value -> new int[value];
int[] intFuncResult = intFunction.apply(20);
Supplier<Object> statSup = () -> staticSupplier();
statSup = MethodReferences::staticSupplier;
Object statSupResult = statSup.get();
Supplier<Object> instSup = new MethodReferences()::instanceSupplier;
instSup = new MethodReferences()::instanceSupplier;
Object instSupResult = instSup.get();
Function<MethodReferences, Object> anonInstFunc = streamDemo -> streamDemo.anonymousInstanceFunction();
anonInstFunc = MethodReferences::anonymousInstanceFunction;
}
}
|
顺便放几个常用的，jdk自带的函数式接口写法
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
50
51
52
53
54
55
| package org.dromara.streamquery;
import java.math.BigDecimal;
import java.util.function.*;
class Usual {
public static Consumer<Object> consumer() {
return o -> {
};
}
public static Function<Integer, Object> function() {
return o -> o;
}
public static Predicate<Object> predicate() {
return o -> true;
}
public static Supplier<Object> supplier() {
return Object::new;
}
public static BiConsumer<String, Integer> biConsumer() {
return (q, o) -> {
};
}
public static BiFunction<Integer, Long, BigDecimal> biFunction() {
return (q, o) -> new BigDecimal(q).add(BigDecimal.valueOf(o));
}
public static UnaryOperator<Object> unaryOperator() {
return q -> q;
}
public static BinaryOperator<Object> binaryOperator() {
return (a, o) -> a;
}
}
|
Stream
Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。方法全是传入函数作为参数，来达到我们的目的。
java.util.stream (Java Platform SE 8 )
1
2
3
4
5
6
7
8
9
10
11
12
|
List<Integer> sixSixSix =
Stream
.generate(() -> 6)
.limit(3)
.collect(Collectors.toList());
sixSixSix.forEach(System.out::print);
|
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
abc = abc.stream()
.sorted(Comparator.reverseOrder())
.skip(4)
.limit(4)
.collect(Collectors.toList());
System.out.println("我要把传入的list逆序，然后从第五个(元素下标为4)开始取值，取4条");
abc.forEach(System.out::print);
System.out.println();
|
Stream API可以极大提高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
|
private static List<Integer> oldSix() {
List<Integer> sixSixSix = new ArrayList<>(3);
sixSixSix.add(6);
sixSixSix.add(6);
sixSixSix.add(6);
System.out.println("老办法实现一个list，存储3个6");
for (Integer integer : sixSixSix) {
System.out.print(integer);
}
System.out.println();
return sixSixSix;
}
private static List<Integer> newSix() {
List<Integer> sixSixSix = Stream.generate(() -> 6).limit(3).collect(Collectors.toList());
System.out.println("新方法实现一个list，存储3个6");
sixSixSix.forEach(System.out::print);
System.out.println();
return sixSixSix;
}
|
这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。
1
2
3
4
5
6
7
8
9
10
11
|
int pipe = abc.stream()
.filter(i -> i > 'G')
.sorted(Comparator.reverseOrder())
.mapToInt(Object::hashCode)
.sum();
System.out.println("将26个字母组成的集合过滤出大于'G'的，逆序，再获取hashCode值，进行求和");
System.out.println(pipe);
|
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。
1
2
3
4
5
6
7
8
9
|
List<String> terminalOperation = abc.stream()
.map(String::valueOf).map(String::toLowerCase)
.collect(Collectors.toList());
System.out.println("26个大写字母Character集合，转换成String然后转换为小写字符，收集起来");
terminalOperation.forEach(System.out::print);
System.out.println();
|