函数式编程
一个大型程序调用若干底层函数, 这些函数又可以调用其他函数
大任务被一层层拆解并执行
函数是面向过程的程序设计的基本单元
Java不支持单独定义函数, 静态方法视为独立的函数
函数式编程归结为面向过程的程序设计
计算机: CPU执行计算代码, 条件判断还有调整等指令代码, 汇编是最贴近计算机的语言
计算: 数学意义上的计算, 越是抽象的计算, 离计算机硬件越近
编程语言约低级, 越解决计算机, 抽象程度低, 执行效率高. C语言
编程语言越高级, 越贴近计算, 抽象程度高, 执行效率低. Python
函数式编程是抽象程度很高的编程范式, 纯粹的函数式编程语言编写的函数没有任何的变量.
因此, 任一函数, 只要输入确定, 输出就是一定确定的. 称为没有副作用
允许函数本身作为参数传入另一个函数, 还可以返回一个函数
lambda基础
java的实例方法和静态方法, 本质上都相当于过程式语言的函数. 例如C函数:
char* strcpy(char* dest, char* src)
只不过java的实例方法隐含地传入了一个this变量
函数式编程把函数作为基本运算单位, 可以接受函数, 可以返回函数.
支持函数式编程的编码风格称为Lambda表达式
Lambda表达式
参数类型和返回值类型都是由编译器自动推断
FunctionalInterface
单方法接口称之为FunctionalInterface, 用注解@FunctionalInterface标记
@FunctionalInterface
public interface Callable {
V call() throws Exception;
}
@FunctionalInterface
public interface Compare {
int compare(T o1, T o2); // 唯一一个抽象方法, 其他都是`default`和`static`方法
boolean equals(Object obj); // 这是`Object`定义的方法
default Comparator reversed() {
return Collections.reverseOrder();
}
default Comparator thenComparing(Comparator super T> other) {
// ...
}
// ...
}
方法引入
除了Lambda表达式, 可以直接传入方法使用
public static void main(String[] args) {
String[] array = new String[] {"Apple", "Orange", "Banana", "Lemon"};
Arrays.sort(array, Main::cmp); // 直接传入静态方法
/**
* String compareTo(String o), 在实际方法调用的时候为
* `public static int compareTo(this, String o)`
*/
Arrays.sort(array, String::compareTo); // 直接传入静态方法
System.out.println(String.join(", ", array));
}
static int cmp(String s1, String s2) {
return s1.compareTo(s2);
}
方法引用: 某个方法签名和接口恰好一致, 就可以直接传入方法引用
签名一致: 方法参数一致, 返回类型相同, 两个方法签名一致
构造方法引用
public class Main {
public static void main(String[] args) {
List names = List.of("Bob", "Alice", "Tim");
// List persons = new ArrayList<>();
// for (String name: names) {
// persons.add(new Person(name));
// }
List persons = names.stream().map(Person::new).collect(Collectors.toList());
System.out.println(persons);
}
static int cmp(String s1, String s2) {
return s1.compareTo(s2);
}
}
class Person {
String name;
public Person(String name) {
this.name = name;
}
public String toString() {
return "Person" + this.name;
}
}
构造方法的引用写法: 类名::new
构造方法隐式的返回this
总结
FunctionalInterface允许传入
接口实现类
Lambda表达式(只需要列出参数名, 其他由编译器推断类型)
符合方法签名的静态实例
符合方法签名的实例方法 (实例类型被看作第一个参数类型)
符合方法签名的构造方法 (实例方法被看作返回类型)
FunctionalInterface不强制继承关系, 不需要方法名称相同, 只要求方法参数(类型和数量)与方法返回类型相同, 即认为方法签名相同
使用Stream
这个Stream代表任意Java对象序列
区别: java.io / java.util.stream
存储: 顺序读写的byte或char / 顺序输出的任意Java对象实例
用途: 序列化至文件或网络 / 内存计算或者业务逻辑
List用来操作一组已存在的Java对象, Stream输出的元素可能没有预先存储再内存中, 而是实时计算出来的
区别: java.util.List / java.util.stream
元素: 已分配并存储在内存中 / 可能未分配, 实时计算
用途: 操作一组存在的Java对象 / 惰性计算
总结:
可以"存储"有限或者无限个元素, 可能全部存储在内存, 也有根据需要实时计算出来的
一个Stream可以轻易转化为另一个Stream, 不会修改原Stream本身
惰性计算的特定: 一个Stream转另一个Stream时, 只存储了转换规则, 没有任何计算
真正的计算通常发生在最后结果的获取
创建Stream
Stream.of()
创建Stream最简单的方法, 直接使用Stream.of(), 传入可变参数即创建一个能确定输出确定元素的Stream
Stream stream = Stream.of("A", "B", "C", "D");
// forEach()相当于内部循环调用
// 可以传入符合Consumer接口的 void accept(T t)方法引用
stream.forEach(System.out::println);
基于数组或Collection
Stream stream1 = Arrays.stream(new String[] {"A", "B", "C"});
Stream stream2 = List.of("X", "Y", "Z").stream();
stream1.forEach(System.out::println);
stream2.forEach(System.out::println);
数组使用Arrays.stream()方法
Collection直接使用stream()方法即可
上述方法都是现有序列变成stream, 元素是固定的
基于Supplier
使用Stream.generate()方法, 传入一个Supplier对象
Stream会不断调用Supplier.get()方法来不断产生下一个元素
Stream保存的是算法, 可以表示无限队列
public class Main {
public static void main(String[] args) {
Stream natual = Stream.generate(new NatualSupplier());
// 注意: 无限序列必须先编程有限序列再打印
natual.limit(20).forEach(System.out::println);
}
}
class NatualSupplier implements Supplier {
int n = 0;
public Integer get() {
n++;
return n;
}
}
无限循环直接调用forEach()或者count()求值, 会进入死循环
其他方法
创建Stream的第三种方法是通过一些API接口, 直接获得Stream
// 文件读取
try (Stream lines = Files.lines(Paths.get("/path/to/file.txt"))) {
// 每个元素, 表示一行内容
}
// 正则
Pattern p = Pattern.compile("\\s+");
Stream s = p.splitAsStream("The quick brow fox jumps over the lazy dog");
s.forEach(System.out::println);
基本类型
泛型不支持基本类型, 无法进行Stream, 会编译错误.
提供IntStream, LongStream, DoubleStream, 使用基本类型的Stream
使用方法和泛型Stream, 并无大碍.
目的是: 为了避免使用Stream的运行效率低
IntStream is = Arrays.stream(new int[] {1, 2, 4});
LongStream ls = List.of("1", "2", "3").stream().mapToLong(Long::parseLong);
使用map
将一个Stream转换成另一个Stream
map操作, 把一个Stream的每一个元素一一对应到应用了目标函数的结果上
参数接收一个Function对象, 并定义一个apply(), 负责把一个T类型转换成R类型
对任何Java对象都有效
public class Main {
public static void main(String[] args) {
List.of("Apple ", " pear", "ORANGE", "BanaNa ")
.stream()
.map(String::trim) // 去除空格
.map(String::toLowerCase) // 变成小写
.forEach(System.out::println); // 打印
}
}
String[] array = new String[] { " 2019-12-31 ", "2020 - 01-09 ", "2020- 05 - 01 ", "2022 - 02 - 01",
" 2025-01 -01" };
// 请使用map把String[]转换为LocalDate并打印:
Arrays.stream(array)
.map(n -> n.replace(" ", ""))
.map(LocalDate::parse)
.forEach(System.out::println);
使用filter
Stream的转换方法, 对每个元素一一测试, 过滤不满足条件的元素
接受Predicate方法, 定义一个test()方法, 判断元素是否符合条件
可以应用与任何Java对象
public class Main {
public static void main(String[] args) {
Stream.generate(new LocalDateSupplier())
.limit(31)
.filter(ldt -> ldt.getDayOfWeek() == DayOfWeek.SATURDAY || ldt.getDayOfWeek() == DayOfWeek.SUNDAY)
.forEach(System.out::println);
}
}
class LocalDateSupplier implements Supplier {
LocalDate start = LocalDate.of(2020, 1, 1);
int n = -1;
@Override
public LocalDate get() {
n++;
return start.plusDays(n);
}
}
使用reduce
reduce是一个聚合方法, 可以把Stream的所有元素按照函数聚合成一个结果
传入BinaryOperator接口, 定义了一个apply()方法, 负责把上次累加的结果和本地的元素进行运算. 并返回累加的结果.
如果去掉初始值, 并stream为空, 会出现返回Optional对象的情况, 所以我们需要进一步进行判断
public static void main(String[] args) {
// 按行读取配置文件:
List props = List.of("profile=native", "debug=true", "logging=warn", "interval=500");
Map map = props.stream()
// 把k=v转换为Map[k]=v:
.map(kv -> {
String[] ss = kv.split("\\=", 2);
return Map.of(ss[0], ss[1]);
})
// 把所有聚合到一个Map
.reduce(new HashMap(), (m, kv) -> {
m.putAll(kv);
return m;
});
// 打印结果
map.forEach((k, v) -> {
System.out.println(k + " = " + v);
});
}
输出集合
Stream操作分成两种
转换操作: 并不会触发任何计算
聚合操作: 真正的计算从这里开始, 因为要获取具体元素
public class Main {
public static void main (String[] args) {
Stream s1 = Stream.generate(new NatualSupplier());
Stream s2 = s1.map(n -> n * n);
Stream s3 = s2.map(n -> n - 1);
Stream s4 = s3.limit(10);
Long s5 = s4.reduce((long) 0, (acc, n) -> acc + n);
System.out.println(s5);
}
}
class NatualSupplier implements Supplier {
long n = 0;
public Long get() {
System.out.println("调用get()");
n++;
return n;
}
}
s1 -> s3的过程不会有任何计算, 只保留计算过程
s4的聚合开始真正的获取元素, 一直从s1开始计算
不进行s5操作的话, 不会调用get()方法
输出为List
Stream stream = Stream.of("Apple", "", null, "Pear", " ", "Orange");
List list = stream.filter(s -> s != null && !s.isBlank()).collect(Collectors.toList());
System.out.println(list);
Stream 的每个元素收集到List方法是调用collect()方法, 并传入Collectors.toList()对象.
使用collect(Collectors.toSet())可以把Stream每个元素收集到Set中
输出为数组
Stream stream = Stream.of("Apple", "", null, "Pear", " ", "Orange");
List list = stream.filter(s -> s != null && !s.isBlank()).collect(Collectors.toList());
String[] array = list.stream().toArray(String[]::new);
传入的"构造方法"是String[]::new
输出为Map
需要指定两个映射函数, 分别把元素映射为key和value
Stream stream = Stream.of("APPL:Apple", "MSFT:Microsoft");
Map map = stream.collect(Collectors.toMap(
s -> s.substring(0, s.indexOf(':')),
s -> s.substring(s.indexOf(':') + 1)
));
System.out.println(map);
分组输出
List list = List.of("Apple", "Banana", "Blackberry", "Cocount");
Map> groups = list.stream()
.collect(Collectors.groupingBy(s -> s.substring(0, 1), Collectors.toList()));
System.out.println(groups);
使用groupingBy()进行分组输出, 第一个参数, 表示key, 第二个参数表示value
其他操作
排序
List list = List.of("Orange", "apple", "Banana")
.stream()
.sorted(String::compareToIgnoreCase)
.collect(Collectors.toList());
如果需要自定义排序, 传入Comparator即可
去重
List list = List.of("A", "A", "b", "B")
.stream()
.distinct()
.collect(Collectors.toList());
截取
List list = List.of("a", "b", "c", "d", "e")
.stream()
.skip(2) // 跳过多少个元素
.limit(3) // 截取3个
.collect(Collectors.toList());
System.out.println(list);
合并
Stream s1 = List.of("a", "b", "c").stream();
Stream s2 = List.of("d", "c").stream();
Stream s = Stream.concat(s1, s2);
System.out.println(s.collect(Collectors.toList()));
flatMap
flatMap把Stream中的每个元素, 都变成Stream, 然后合并成一个Stream
Stream> s = Stream.of(
Arrays.asList(1, 2, 3),
Arrays.asList(4, 5, 6),
Arrays.asList(7, 8, 9)
);
Stream i = s.flatMap(list -> list.stream());
System.out.println(i.collect(Collectors.toList()));
并行
Stream s = List.of("a", "b", "c", "d").stream();
String[] r = s.parallel() // 此处变为并行处理stream, 提高处理效率
.sorted()
.toArray(String[]::new);
for (String i : r) {
System.out.println(i);
}
System.out.println(r);
其他聚合方法
其他的聚合方法:
count(): 返回stream中元素个数
max(Comparator super T> cp): 找出最大元素
针对IntStream, LongStream和DoubleStream:
sum(): 求和操作
average(): 对所有元素求平均数
测试Stream的元素是否满足条件
boolean allMatch(Predicate super T>): 测试所有元素是否满足测试条件
boolean anyMatch(Predicate super T>: 测试至少有一个元素满足条件
forEach()循环处理每一个元素
s.forEach(System.out::println);
困惑
String[]::new到底是个什么
相当于 size -> new String[size]