1. Lambda表达式
1.1 函数式编程思想概述
在数学中,函数就是有输入量、输出量的一套计算方案,也就是“拿什么东西做什么事情”。相对而言,面向对象过分强调“必须通过对象的形式来做事情”,而函数式思想则尽量忽略面向对象的复杂语法——强调做什么,而不是以什么形式做。
传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那,有没有更加简单的办法?如果我们将关注点从“怎么做”回归到“做什么”的本质上,就会发现只要能够更好地达到目的,过程与形式其实并不重要。
1.2 Lambda的优化
当需要启动一个线程去完成任务时,通常会通过java.lang.Runnable
接口来定义任务内容,并使用java.lang.Thread
类来启动该线程。
传统写法,代码如下:
public class Demo03Thread {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程任务执行!");
}
}).start();
}
}
本着“一切皆对象”的思想,这种做法是无可厚非的:首先创建一个Runnable
接口的匿名内部类对象来指定任务内容,再将其交给一个线程来启动。
代码分析:
对于Runnable
的匿名内部类用法,可以分析出几点内容:
Thread
类需要Runnable
接口作为参数,其中的抽象run
方法是用来指定线程任务内容的核心;- 为了指定
run
的方法体,不得不需要Runnable
接口的实现类; - 为了省去定义一个
RunnableImpl
实现类的麻烦,不得不使用匿名内部类; - 必须覆盖重写抽象
run
方法,所以方法名称、方法参数、方法返回值不得不再写一遍,且不能写错; - 而实际上,似乎只有方法体才是关键所在。
Lambda表达式写法,代码如下:
借助Java 8的全新语法,上述Runnable
接口的匿名内部类写法可以通过更简单的Lambda表达式达到等效:
public class Demo04LambdaRunnable {
public static void main(String[] args) {
new Thread(() -> System.out.println("多线程任务执行!")).start(); // 启动线程
}
}
这段代码和刚才的执行效果是完全一样的,可以在1.8或更高的编译级别下通过。从代码的语义中可以看出:我们启动了一个线程,而线程任务的内容以一种更加简洁的形式被指定。
不再有“不得不创建接口对象”的束缚,不再有“抽象方法覆盖重写”的负担,就是这么简单!
1.3 Lambda的格式
1.3.1 标准格式:
Lambda省去面向对象的条条框框,格式由3个部分组成:
- 一些参数
- 一个箭头
- 一段代码
Lambda表达式的标准格式为:
(参数类型 参数名称) -> { 代码语句 }
格式说明:
- 小括号内的语法与传统方法参数列表一致:无参数则留空;多个参数则用逗号分隔。
->
是新引入的语法格式,代表指向动作。- 大括号内的语法与传统方法体要求基本一致。
匿名内部类与lambda对比:
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程任务执行!");
}
}).start();
仔细分析该代码中,Runnable
接口只有一个run
方法的定义:
public abstract void run();
即制定了一种做事情的方案(其实就是一个方法):
- 无参数:不需要任何条件即可执行该方案。
- 无返回值:该方案不产生任何结果。
- 代码块(方法体):该方案的具体执行步骤。
同样的语义体现在Lambda
语法中,要更加简单:
() -> System.out.println("多线程任务执行!")
- 前面的一对小括号即
run
方法的参数(无),代表不需要任何条件; - 中间的一个箭头代表将前面的参数传递给后面的代码;
- 后面的输出语句即业务逻辑代码。
1.3.2 参数和返回值:
下面举例演示java.util.Comparator<T>
接口的使用场景代码,其中的抽象方法定义为:
public abstract int compare(T o1, T o2);
当需要对一个对象数组进行排序时,Arrays.sort
方法需要一个Comparator
接口实例来指定排序的规则。假设有一个Person
类,含有String name
和int age
两个成员变量:
public class Person {
private String name;
private int age;
// 省略构造器、toString方法与Getter Setter
}
传统写法
如果使用传统的代码对Person[]
数组进行排序,写法如下:
public class Demo05Comparator {
public static void main(String[] args) {
// 本来年龄乱序的对象数组
Person[] array = { new Person("古力娜扎", 19), new Person("迪丽热巴", 18), new Person("马尔扎哈", 20) };
// 匿名内部类
Comparator<Person> comp = new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
};
Arrays.sort(array, comp); // 第二个参数为排序规则,即Comparator接口实例
for (Person person : array) {
System.out.println(person);
}
}
}
这种做法在面向对象的思想中,似乎也是“理所当然”的。其中Comparator
接口的实例(使用了匿名内部类)代表了“按照年龄从小到大”的排序规则。
代码分析
下面我们来搞清楚上述代码真正要做什么事情。
- 为了排序,
Arrays.sort
方法需要排序规则,即Comparator
接口的实例,抽象方法compare
是关键; - 为了指定
compare
的方法体,不得不需要Comparator
接口的实现类; - 为了省去定义一个
ComparatorImpl
实现类的麻烦,不得不使用匿名内部类; - 必须覆盖重写抽象
compare
方法,所以方法名称、方法参数、方法返回值不得不再写一遍,且不能写错; - 实际上,只有参数和方法体才是关键。
Lambda写法
public class Demo06ComparatorLambda {
public static void main(String[] args) {
Person[] array = {
new Person("古力娜扎", 19),
new Person("迪丽热巴", 18),
new Person("马尔扎哈", 20) };
Arrays.sort(array, (Person a, Person b) -> {
return a.getAge() - b.getAge();
});
for (Person person : array) {
System.out.println(person);
}
}
}
1.3.3 省略格式:
省略规则
在Lambda标准格式的基础上,使用省略写法的规则为:
- 小括号内参数的类型可以省略;
- 如果小括号内有且仅有一个参,则小括号可以省略;
- 如果大括号内有且仅有一个语句,则无论是否有返回值,都可以省略大括号、return关键字及语句分号。
备注:掌握这些省略规则后,请对应地回顾本章开头的多线程案例。
可推导即可省略
Lambda强调的是“做什么”而不是“怎么做”,所以凡是可以推导得知的信息,都可以省略。例如上例还可以使用Lambda的省略写法:
Runnable接口简化:
1. () -> System.out.println("多线程任务执行!")
Comparator接口简化:
2. Arrays.sort(array, (a, b) -> a.getAge() - b.getAge());
1.4 Lambda的前提条件
Lambda的语法非常简洁,完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意:
- 使用Lambda必须具有接口,且要求接口中有且仅有一个抽象方法。
无论是JDK内置的Runnable
、Comparator
接口还是自定义的接口,只有当接口中的抽象方法存在且唯一时,才可以使用Lambda。 - 使用Lambda必须具有接口作为方法参数。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型,才能使用Lambda作为该接口的实例。
备注:有且仅有一个抽象方法的接口,称为“函数式接口”。
2. 函数式接口
2.1 概述
函数式接口在Java中是指:有且仅有一个抽象方法的接口。
函数式接口,即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda,所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地进行推导。
备注:从应用层面来讲,Java中的Lambda可以看做是匿名内部类的简化格式,但是二者在原理上不同。
2.2 格式
只要确保接口中有且仅有一个抽象方法即可:
修饰符 interface 接口名称 {
public abstract 返回值类型 方法名称(可选参数信息);
// 其他非抽象方法内容
}
由于接口当中抽象方法的public abstract
是可以省略的,所以定义一个函数式接口很简单:
public interface MyFunctionalInterface {
void myMethod();
}
2.2.1 自定义函数式接口
对于刚刚定义好的MyFunctionalInterface
函数式接口,典型使用场景就是作为方法的参数:
public class Demo07FunctionalInterface {
// 使用自定义的函数式接口作为方法参数
private static void doSomething(MyFunctionalInterface inter) {
inter.myMethod(); // 调用自定义的函数式接口方法
}
public static void main(String[] args) {
// 调用使用函数式接口的方法
doSomething(() -> System.out.println("Lambda执行啦!"));
}
}
2.2.2 FunctionalInterface注解
与@Override
注解的作用类似,Java 8中专门为函数式接口引入了一个新的注解:@FunctionalInterface
。该注解可用于一个接口的定义上:
@FunctionalInterface
public interface MyFunctionalInterface {
void myMethod();
}
一旦使用该注解来定义接口,编译器将会强制检查该接口是否确实有且仅有一个抽象方法,否则将会报错。不过,即使不使用该注解,只要满足函数式接口的定义,这仍然是一个函数式接口,使用起来都一样。
2.3 常用函数式接口
JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景,它们主要在java.util.function
包中被提供。下面是两个常用的函数式接口及使用示例。
2.3.1 Consumer接口
java.util.function.Consumer<T>
接口,是消费一个数据,其数据类型由泛型参数决定。
抽象方法:accept
Consumer
接口中包含抽象方法void accept(T t)
: 消费一个指定泛型的数据。
基本使用如:
//给你一个字符串,请按照大写的方式进行消费
import java.util.function.Consumer;
public class Demo08Consumer {
public static void main(String[] args) {
String str = "Hello World";
//1.lambda表达式标准格式
fun(str,(String s)->{
System.out.println(s.toUpperCase());
});
//2.lambda表达式简化格式
fun(str,s-> System.out.println(s.toUpperCase()));
}
/*
定义方法,使用Consumer接口作为参数
fun方法: 消费一个String类型的变量
*/
public static void fun(String s,Consumer<String> con) {
con.accept(s);
}
}
2.3.2 Predicate接口
有时候我们需要对某种类型的数据进行判断,从而得到一个boolean值结果。这时可以使用java.util.function.Predicate<T>
接口。
抽象方法:test
Predicate
接口中包含一个抽象方法:boolean test(T t)
。用于条件判断的场景:
//1.练习:判断字符串长度是否大于5
//2.练习:判断字符串是否包含"H"
public class Demo09Predicate {
private static void method(Predicate<String> predicate,String str) {
boolean veryLong = predicate.test(str);
System.out.println("字符串很长吗:" + veryLong);
}
public static void main(String[] args) {
method(s -> s.length() > 5, "HelloWorld");
}
}
条件判断的标准是传入的Lambda表达式逻辑,只要字符串长度大于5则认为很长。
3. Stream流
在Java 8中,得益于Lambda所带来的函数式编程,引入了一个全新的Stream概念,stream是⽤于对集合迭代器的增强,使之完成 能够完成更⾼效的聚合操作(过滤、排序、统计分组)或者⼤批量数据操作。此外与stream 与lambda 表达示结合后编码效率与⼤⼤提⾼,并且可读性更强。
举例:
public static ArrayList<Apple> apples = new ArrayList<>();
static {
apples.add(new Apple(1, "red", 100, "江西"));
apples.add(new Apple(2, "red", 200, "江西"));
apples.add(new Apple(3, "red", 300, "江西"));
apples.add(new Apple(4, "red", 400, "江西"));
apples.add(new Apple(5, "black", 100, "江西"));
apples.add(new Apple(6, "black", 200, "江西"));
apples.add(new Apple(7, "black", 300, "江西"));
apples.add(new Apple(8, "black", 400, "江西"));
}
需求1: 获取所有红色苹果的总重量
int sum = apples.stream().filter(a -> "red".equals(a.getColor())).mapToInt(Apple::getWeight).sum();
System.out.println("sum = " + sum);
需求2: 基于颜色统计平均重量
Map<String, Double> collect = apples.stream().collect(Collectors.groupingBy(Apple::getColor, Collectors.averagingInt(Apple::getWeight)));
System.out.println("collect = " + collect);
以上两个查询类似于数据库的下面两条sql
//获取所有红色苹果的总重量
select sum(a.weight) from apple as a where a.color='red';
// 基于颜色分组统计重量
select a.color,sum(a.weight) from apple as a group by color;
3.1 创建对象流的三种方式:
- 由集合对象创建流。
对支持流处理的对象调用 stream()。支持流处理的对象包括 Collection 集合及其子类
List<Integer> list = Arrays.asList(1,2,3);
Stream<Integer> stream = list.stream();
- 由数组创建流。通过静态方法 Arrays.stream() 将数组转化为流(Stream)
IntStream stream = Arrays.stream(new int[]{3, 2, 1});
- 通过静态方法 Stream.of() ,但是底层其实还是调用 Arrays.stream()
Stream stream = Stream.of(1, 2, 3);
注意:
还有两种比较特殊的流:
- 空流:Stream.empty()
- 无限流:Stream.generate() 和 Stream.iterate()。
可以配合 limit() 使用可以限制一下数量
// 接受一个 Supplier 作为参数
Stream.generate(Math::random).limit(10).forEach(System.out::println);
// 初始值是 0,新值是前一个元素值 + 2
Stream.iterate(0, n -> n + 2).limit(10).forEach(System.out::println);
3.2 Stream执行机制解密
- 不存储数据
- 不会改变数据源
- 不可以重复使用
stream 所有操作组合在⼀起即变成了管道,管道中有以下两种操作:
- 中间操作: 调⽤中间操作⽅法会返回⼀个新的流。通过连续执⾏多个操作倒便就组成了Stream中的执⾏管道(pipeline)。需要注意的是这些管道被添加后并不会真正执⾏,只有等到调⽤终值操作之后才会执⾏。
- 终值操作: 在调⽤该⽅法后,将执⾏之前所有的中间操作,获返回结果结束对流的使⽤流的执⾏顺序说明:其每个元素挨着作为参数去调⽤中间操作及终值操作,⽽不是遍历完⼀个⽅法,在遍历下⼀个⽅法。
如何查看是否是中间操作还是终值操作,其实很简单,只需要看方法的返回值是否是stream流或其子接口就行,如果是,则是中间操作,如果返回的是不是流,是其他值,则是终值操作
Stream 中的常⽤API及场景
⽅法 | 描述 | 操作类型 |
---|---|---|
filter | 接收⼀个Boolean表达示来过滤元素 | 中间操作 |
map | 将流中元素 1:1 映谢成另外⼀个元素 | 中间操作 |
mapToInt | 将流中元素映谢成int,mapToLong、mapToDouble操作类似⽬的减少 装箱拆箱带来的损耗 | 中间操作 |
flatMap | 如map时返回的是⼀个List, 将会进⼀步拆分。详⻅flatMap示例 | 中间操作 |
forEach | 遍历流中所有元素 | 终值操作 |
sorted | 排序 | 中间操作 |
peek | 遍历流中所有元素 ,对比ForEach不同在于不会结束流 中间操作toArray 将流中元素转换成⼀个数组返回 | 终值操作 |
reduce | 归约合并操作 | 中间操作 |
collect | 采集数据,返回⼀个新的结果 参数说明:Supplier: 采集需要返回的结果BiConsumer<R, ? super T>:传递结果与元素进⾏合并。BiConsumer<R, R>:在并发执⾏的时候 结果合并操作。详⻅ collec示例 | 终值操作 |
distinct | 基于equal 表达示去重 | 中间操作 |
max | 通过⽐较函数 返回最⼤值 | 终值操作 |
anyMatch | 流中是否有任⼀元素满⾜表达式 | 终值操作 |
allMatch | 流中所有元素满⾜表达示返回true | 终值操作 |
noneMatch | 与allMatch 相反,都不满⾜的情况下返回 true | 终值操作 |
findFirst | 找出流中第⼀个元素 | 终值操作 |
of | ⽣成流 | ⽣成流操作 |
iterate | 基于迭代⽣成流 | ⽣成流操作 |
generate | 基于迭代⽣成流,与iterate 不同的是不 后⼀元素的⽣成,不依赖前⼀元素 | ⽣成流操作 |
concat | 合并两个相同类型的类 | ⽣成流操作 |
3.3 Collectors 中的常⽤API及场景
⽅法 | 描述 |
---|---|
toList | 转换成list |
toMap | 转换成map |
groupingBy | 统计分组 |
averagingInt | 求平均值 |
summingInt | 求总值 |
maxBy | 获取最⼤值 |
3.4 常用方法
流模型的操作很丰富,这里介绍一些常用的API。这些方法可以被分成两种:
- 终结方法:返回值类型不再是
Stream
接口自身类型的方法,因此不再支持类似StringBuilder
那样的链式调用。本小节中,终结方法包括count
和forEach
方法。 - 非终结方法:返回值类型仍然是
Stream
接口自身类型的方法,因此支持链式调用。(除了终结方法外,其余方法均为非终结方法。)
备注:本小节之外的更多方法,请自行参考API文档。
3.4.1 forEach : 逐一处理
虽然方法名字叫forEach
,但是与for循环中的“for-each”昵称不同,该方法并不保证元素的逐一消费动作在流中是被有序执行的。
void forEach(Consumer<? super T> action);
该方法接收一个Consumer
接口函数,会将每一个流元素交给该函数进行处理。例如:
import java.util.stream.Stream;
public class Demo15StreamForEach {
public static void main(String[] args) {
Stream<String> stream = Stream.of("大娃","二娃","三娃","四娃","五娃","六娃","七娃","爷爷","蛇精","蝎子精");
//Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
stream.forEach((String str)->{System.out.println(str);});
}
}
在这里,lambda表达式(String str)->{System.out.println(str);}
就是一个Consumer函数式接口的示例。
3.4.2 filter:过滤
可以通过filter
方法将一个流转换成另一个子集流。方法声明:
Stream<T> filter(Predicate<? super T> predicate);
该接口接收一个Predicate
函数式接口参数(可以是一个Lambda)作为筛选条件。
基本使用
Stream流中的filter
方法基本使用的代码如:
public class Demo16StreamFilter {
public static void main(String[] args) {
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
Stream<String> result = original.filter((String s) -> {return s.startsWith("张");});
}
}
在这里通过Lambda表达式来指定了筛选的条件:必须姓张。
3.4.3 count:统计个数
正如旧集合Collection
当中的size
方法一样,流提供count
方法来数一数其中的元素个数:
long count();
该方法返回一个long值代表元素个数(不再像旧集合那样是int值)。基本使用:
public class Demo17StreamCount {
public static void main(String[] args) {
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
Stream<String> result = original.filter(s -> s.startsWith("张"));
System.out.println(result.count()); // 2
}
}
3.4.4 limit:取用前几个
limit
方法可以对流进行截取,只取用前n个。方法签名:
Stream<T> limit(long maxSize):获取Stream流对象中的前n个元素,返回一个新的Stream流对象
参数是一个long型,如果集合当前长度大于参数则进行截取;否则不进行操作。基本使用:
import java.util.stream.Stream;
public class Demo18StreamLimit {
public static void main(String[] args) {
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
Stream<String> result = original.limit(2);
System.out.println(result.count()); // 2
}
}
3.4.5 skip:跳过前几个
如果希望跳过前几个元素,可以使用skip
方法获取一个截取之后的新流:
Stream<T> skip(long n): 跳过Stream流对象中的前n个元素,返回一个新的Stream流对象
如果流的当前长度大于n,则跳过前n个;否则将会得到一个长度为0的空流。基本使用:
import java.util.stream.Stream;
public class Demo19StreamSkip {
public static void main(String[] args) {
Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
Stream<String> result = original.skip(2);
System.out.println(result.count()); // 1
}
}
3.4.6 concat:组合
如果有两个流,希望合并成为一个流,那么可以使用Stream
接口的静态方法concat
:
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b): 把参数列表中的两个Stream流对象a和b,合并成一个新的Stream流对象
备注:这是一个静态方法,与
java.lang.String
当中的concat
方法是不同的。
该方法的基本使用代码如:
import java.util.stream.Stream;
public class Demo20StreamConcat {
public static void main(String[] args) {
Stream<String> streamA = Stream.of("张无忌");
Stream<String> streamB = Stream.of("张翠山");
Stream<String> result = Stream.concat(streamA, streamB);
}
}