Java函数式编程#
基础使用#
1
2
| String[] array = new String[] { "Apple", "Orange", "Banana", "Lemon" };
Arrays.sort(array,(o1,o2)->o2.compareTo(o1));
|
传入方法#
方法签名和接口一致时,在这里,方法签名只看参数类型和返回类型,不看方法名称,也不看类的继承关系
1
2
3
4
5
6
7
8
9
| public static void main(String[] args) {
String[] array = new String[] { "Apple", "Orange", "Banana", "Lemon" };
Arrays.sort(array, Main::cmp);
}
//
static int cmp(String s1, String s2) {
return s1.compareTo(s2);
}
|
构造方法引用
流式API#
全新的流式API:Stream API,位于Java.util.stream包
这个Stream不同于Java.io的InputStream和OutputStream,它代表的是任意Java对象的序列
这个Stream和List也不一样,List存储的每个元素都是已经存储在内存中的某个Java对象,而Stream输出的元素可能并没有预先存储在内存中,而是实时计算出来的,惰性计算
1
2
3
4
| Stream<BigInteger> naturals = createNaturalStream(); // 不计算
Stream<BigInteger> s2 = naturals.map(BigInteger::multiply); // 不计算
Stream<BigInteger> s3 = s2.limit(100); // 不计算
s3.forEach(System.out::println); // 计算
|
惰性计算的特点是:一个Stream转换为另一个Stream时,实际上只存储了转换规则,并没有任何计算发生
Stream API的基本用法就是:创建一个Stream,然后做若干次转换,最后调用一个求值方法获取真正计算的结果
1
2
3
4
5
| int result = createNaturalStream() // 创建Stream
.filter(n -> n % 2 == 0) // 任意个转换
.map(n -> n * n) // 任意个转换
.limit(100) // 任意个转换
.sum(); // 最终计算结果
|
创建Stream#
Stream.of:Stream<String> stream = Stream.of("A", "B", "C", "D")
1
| Stream.of("A","B","C").forEach(System.out::println);
|
基于数组或Collection:Arrays.stream(),collection.stream()
1
2
| Stream<String> stream1 = Arrays.stream(new String[] { "A", "B", "C" });
Stream<String> stream2 = List.of("X", "Y", "Z").stream();
|
基于Supplier:Stream.generate()方法,它需要传入一个Supplier对象;基于Supplier创建的Stream会不断调用Supplier.get()方法来不断产生下一个元素,这种Stream保存的不是元素,而是算法,它可以用来表示无限序列
基本类型:IntStream、LongStream和DoubleStream这三种使用基本类型的Stream
Stream.map()#
map()方法用于将一个Stream的每个元素映射成另一个元素并转换成一个新的Stream;
可以将一种元素类型转换成另一种元素类型。
1
2
3
4
5
6
| //字符串转化为日期,并打印
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
List.of("2021-12-12","2021-12-13","2021-12-14")
.stream()
.map(n->sdf.parse(n))
.forEach(System.out::println);
|
Stream.flatMap()#
flatMap()对流扁平化处理
1
2
3
4
5
6
7
8
9
10
11
12
13
| private static void streamTest4() {
List<String> list = new ArrayList<>();
list.add("123,234");
list.add("3456");
list.add("456,789");
Set<String> strings = list.stream().map(e -> e.split(","))
.flatMap(Arrays::stream)
.collect(Collectors.toSet());
// 输出:[123, 234, 3456, 456, 789]
System.out.println(strings);
}
|
解释:map 操作获得一个 String[] 流,然后通过 flatMap 将 String[] 生成的新流的新流
Stream.filter()#
filter()操作,就是对一个Stream的所有元素一一进行测试,不满足条件的就被“滤掉”了,剩下的满足条件的元素就构成了一个新的Stream
filter()方法接收的对象是Predicate接口对象,它定义了一个test()方法,负责判断元素是否符合条件
1
2
3
4
5
6
7
| // 过滤成绩小于15的Person
Person p1=new Person("张三",12);
Person p2=new Person("李四",21);
Person p3=new Person("王五",35);
List.of(p1,p2,p3).stream()
.filter(n->n.score>15)
.forEach(System.out::println);
|
Stream.reduce()#
reduce()是Stream的一个聚合方法,它可以把一个Stream的所有元素按照聚合函数聚合成一个结果
reduce()方法传入的对象是BinaryOperator接口,它定义了一个apply()方法,负责把上次累加的结果和本次的元素 进行运算,并返回累加的结果
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
| int sum = 0;
for (n : stream) {
sum = (sum, n) -> sum + n;
}
// 将配置文件的每一行配置通过map()和reduce()操作聚合成一个Map<String, String>
List<String> props = List.of("profile=native", "debug=true", "logging=warn", "interval=500");
Map<String,String> map=props.stream()
.map((kv)->{
String[] ss = kv.split("\\=", 2);
return Map.of(ss[0],ss[1]);
})
.reduce(new HashMap<>(),(o,v)->{
o.putAll(v);
return o;
});
map.forEach((k,v)->{
System.out.println(k+":"+v);
});
//分组后根据某个属性分组,然后每组再次聚合,自定义收集器,返回Map
Map<String,BigDecimal> res=list.stream().collect(
Collectors.groupingBy(Material::getType,
Collectors.reducing(BigDecimal.ZERO, Material::getMoney, BigDecimal::add)));
//对 bigdecimal 求和
BigDecimal bigDecimal = decimalList.stream().filter(Objects::nonNull).reduce(BigDecimal.ZERO, (res,v)->{
return res.add(v);
});
|
输出集合#
输出为List:调用collect()并传入Collectors.toList()对象,类似有Collectors.toSet()输出集合
1
2
3
4
5
6
7
| //输出list,并过滤掉无用元素
List<String> list=Stream.of("Apple", "", null, "Pear", " ", "Orange")
.filter(s -> s != null && !s.isBlank())
.collect(Collectors.toList());
list.forEach((v)->{
System.out.println(v);
});
|
输出为数组:toArray(String[]::new)
1
2
| List<String> list = List.of("Apple", "Banana", "Orange");
String[] array = list.stream().toArray(String[]::new);
|
输出为Map
1
2
3
4
5
6
7
| Stream<String> stream = Stream.of("APPL:Apple", "MSFT:Microsoft");
Map<String, String> map = stream
.collect(Collectors.toMap(
// 把元素s映射为key:
s -> s.substring(0, s.indexOf(':')),
// 把元素s映射为value:
s -> s.substring(s.indexOf(':') + 1)));
|
分组输出:分组输出使用Collectors.groupingBy(),它需要提供两个函数:一个是分组的key,第二个是分组的value
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| // 根据classID,分组,返回Map(Integer,List<Student>)
List<Student> studentList=new ArrayList<>();
for (int i=1;i<10;i++){
Student s1=new Student(20%i,"张"+i);
studentList.add(s1);
}
Map<Integer, List<Student>> groups=studentList.stream()
.collect(Collectors.groupingBy(stu->stu.classId,Collectors.toList()));
groups.forEach((k,v)->{
System.out.print(k+":");
v.forEach((lv)->{
System.out.print(lv+",");
});
System.out.println();
});
|
anyMatch表示,判断的条件里,任意一个元素成功,返回true
allMatch表示,判断条件里的元素,所有的都是,返回true
noneMatch跟allMatch相反,判断条件里的元素,所有的都不是,返回true
1
2
3
4
5
6
7
8
9
| List<String> strs = Arrays.asList("a", "a", "a", "a", "b");
boolean aa = strs.stream().anyMatch(str -> str.equals("a"));
boolean bb = strs.stream().allMatch(str -> str.equals("a"));
boolean cc = strs.stream().noneMatch(str -> str.equals("a"));
long count = strs.stream().filter(str -> str.equals("a")).count();
System.out.println(aa);// TRUE
System.out.println(bb);// FALSE
System.out.println(cc);// FALSE
System.out.println(count);// 4
|
collectingAndThen()#
Collectors.collectingAndThen(Collector下游,函数完成器),先进行结果集的收集,然后将收集到的结果集进行下一步的处理
第一个参数是Collector接口的子类,所以还是对于Collector的处理,Collectors工具类里面的toList()、toSet()、joining()、mapping()、collectingAndThen()等几乎所有的方法都可以使用
第二个参数是一个Function函数,Function函数是这样的:R apply(T t),他调用的ArrayList的有参构造方法
1
2
3
4
5
6
7
8
9
10
| // list去重
//将集合放到TreeSet中,然后再将TreeSet转为List, 其中TreeSet要传入一个根据哪个属性进行比较的比较器,然后使用public ArrayList(Collection<? extends E> c)将TreeSet放入构造器中生成List
collect = personList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(()->
new TreeSet<>(Comparator.comparing(e->e.name+e.score))
), ArrayList::new));
//创建不变map
personList.stream().collect(Collectors.collectingAndThen(Collectors.toMap(e ->
e.score+e.name, e -> e.score
), HashMap::new));
|
Collector与Collectors#
Collector是专门用来作为Stream的collect方法的参数的
Collectors是作为生产具体Collector的工具类
Collector
Collector主要包含五个参数
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
| /*
* T 入参类型
* A 容器类型
* R 结果类型
*/
public interface Collector<T, A, R> {
/*
* supplier参数用于生成结果容器,容器类型为A
* 返回一个结果为空的 Supplier,也就是一个无参数函数,在调用时它会创建一个空的累加器实例,供数据收集过程使用
*/
Supplier<A> supplier();
/*
* accumulator用于消费元素,也就是归纳元素,这里的T就是元素,它会将流中的元素一个一个与结果容器A发生操作
* 返回执行归约操作的函数,当遍历到流中第n个元素时,
* 这个函数执行时会有两个参数:保存归约结果的累加器(已收集了流中的前 n-1 个项目),还有第n个元素本身
* 该函数将返回 void ,因为累加器是原位更新,即函数的执行改变了它的内部状态
*/
BiConsumer<A, T> accumulator();
/*
* combiner用于两个两个合并并行执行的线程的执行结果,将其合并为一个最终结果A
* combiner 方法会返回一个供归约操作使用的函数,
* 它定义了对流的各个子部分进行并行处理时,各个子部分归约所得的累加器要如何合并
*/
BinaryOperator<A> combiner();
/* finisher用于将之前整合完的结果R转换成为A
* 在遍历完流后, finisher 方法必须返回在累积过程的最后要调用的一个函数,
* 以便将累加器对象转换为整个集合操作的最终结果
*/
Function<A, R> finisher();
/*
* NORDERED —— 归约结果不受流中项目的遍历和累积顺序的影响
* CONCURRENT —— accumulator 函数可以从多个线程同时调用,且该收集器可以并行归约流。如果收集器没有标为 UNORDERED ,那它仅在用于无序数据源时才可以并行归约
* IDENTITY_FINISH —— 这表明完成器方法返回的函数是一个恒等函数,可以跳过。这种情况下,累加器对象将会直接用作归约过程的最终结果。这也意味着,将累加器 A 不加检查地转换为结果 R 是安全的
*/
Set<Characteristics> characteristics();
}
|
Collector拥有两个of方法用于生成Collector实例,其中一个拥有上面所有五个参数,另一个四个参数,不包括finisher
Collectors
Collectors是一个工具类,是JDK预实现Collector的工具类,它内部提供了多种Collector,我们可以直接拿来使用
通过Collector的of方法自定义Collector收集器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| //自定义collector实现,作用将BigDecimal求和,对于null忽略
Collector<BigDecimal,BigDecimal[],BigDecimal> collector=Collector.of(
()-> new BigDecimal[1],
(a, t) -> {
//这里对结果容器赋初始值
if (a[0] == null) {
a[0] = BigDecimal.ZERO;
}
//这里忽略流中null元素
if (t!=null){
a[0] = a[0].add(t);
}
},
(a, b) -> {
a[0] = a[0].add(b[0]);
return a;
},
a -> a[0],
Collector.Characteristics.IDENTITY_FINISH);
list.stream().collect(collector);
|
自定义实现类实现Collectors
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
56
| // T 是流中要收集的项目的泛型
// A 是累加器的类型,累加器是在收集过程中用于累积部分结果的对象
// R 是收集操作得到的对象(通常但并不一定是集合)的类型
new Collector<BigDecimal, BigDecimal[], String>() {
/**
* 建立新的结果容器
*/
@Override
public Supplier<BigDecimal[]> supplier() {
return () -> new BigDecimal[1];
}
/**
* 将元素添加到结果容器
*/
@Override
public BiConsumer<BigDecimal[], BigDecimal> accumulator() {
return (a,t)->{
if (a[0]==null){
a[0]=BigDecimal.ZERO;
}
if (t != null){
a[0]=a[0].add(t);
}
};
}
/**
* 合并两个结果容器
*/
@Override
public BinaryOperator<BigDecimal[]> combiner() {
return (a1,a2)->{
a1[0]=a1[0].add(a2[0]);
return a1;
};
}
/**
* 对结果容器应用最终转换
*/
@Override
public Function<BigDecimal[], String> finisher() {
return (a)-> a[0].toString();
}
/**
* 定义了收集器特性
*/
@Override
public Set<Characteristics> characteristics() {
return Collections.unmodifiableSet(EnumSet.of(
Characteristics.CONCURRENT,
Collector.Characteristics.UNORDERED));
}
}
|
Stream提供的常用操作有:
转换操作:map(),filter(),sorted(),distinct();
合并操作:concat(),flatMap();
并行处理:parallel();
聚合操作:reduce(),collect(),count(),max(),min(),sum(),average();
其他操作:allMatch(), anyMatch(), forEach()
java提供的函数接口#
Function函数#
| 接口 | 描述 |
|---|
| Function<T,R> | 接收一个参数并返回结果的函数 |
| BiFunction<T,U,R> | 接受两个参数并返回结果的函数 |
| DoubleFunction<R> | 接收一个double类型的参数并返回结果的函数 |
| DoubleToIntFunction | 接收一个double类型的参数并返回int结果的函数 |
| DoubleToLongFunction | 接收一个double类型的参数并返回long结果的函数 |
| IntFunction<R> | 接收一个int类型的参数并返回结果的函数 |
| IntToDoubleFunction | 接收一个int类型的参数并返回double结果的函数 |
| IntToLongFunction | 接收一个int类型的参数并返回long结果的函数 |
| LongFunction<R> | 接收一个long类型的参数并返回结果的函数 |
| LongToDoubleFunction | 接收一个long类型的参数并返回double结果的函数 |
| LongToIntFunction | 接收一个long类型的参数并返回int结果的函数 |
| ToDoubleBiFunction<T,U> | 接收两个参数并返回double结果的函数 |
| ToDoubleFunction<T> | 接收一个参数并返回double结果的函数 |
| ToIntBiFunction<T,U> | 接收两个参数并返回int结果的函数 |
| ToIntFunction<T> | 接收一个参数并返回int结果的函数 |
| ToLongBiFunction<T,U> | 接收两个参数并返回long结果的函数 |
| ToLongFunction<T> | 接收一个参数并返回long结果的函数 |
Consumer消费者#
| 接口 | 描述 |
|---|
| Consumer<T> | 提供一个T类型的输入参数,不返回执行结果 |
| BiConsumer<T,U> | 提供两个自定义类型的输入参数,不返回执行结果 |
| DoubleConsumer | 表示接受单个double值参数,但不返回结果的操作 |
| IntConsumer | 表示接受单个int值参数,但不返回结果的操作 |
| LongConsumer | 表示接受单个long值参数,但不返回结果的操作 |
| ObjDoubleConsumer<T> | 表示接受object值和double值,但是不返回任何操作结果 |
| ObjIntConsumer<T> | 表示接受object值和int值,但是不返回任何操作结果 |
| ObjLongConsumer<T> | 表示接受object值和long值,但是不返回任何操作结果 |
Predicate谓语#
| 接口 | 描述 |
|---|
| Predicate<T> | 对给定的输入参数执行操作,返回一个boolean类型的结果(布尔值函数) |
| BiPredicate<T,U> | 对给定的两个输入参数执行操作,返回一个boolean类型的结果(布尔值函数) |
| DoublePredicate | 对给定的double参数执行操作,返回一个boolean类型的结果(布尔值函数) |
| IntPredicate | 对给定的int输入参数执行操作,返回一个boolean类型的结果(布尔值函数) |
| LongPredicate | 对给定的long参数执行操作,返回一个boolean类型的结果(布尔值函数) |
Supplier供应商#
| 接口 | 描述 |
|---|
| Supplier<T> | 不提供输入参数,但是返回结果的函数 |
| BooleanSupplier | 不提供输入参数,但是返回boolean结果的函数 |
| DoubleSupplier | 不提供输入参数,但是返回double结果的函数 |
| IntSupplier | 不提供输入参数,但是返回int结果的函数 |
| LongSupplier | 不提供输入参数,但是返回long结果的函数 |
Operator操作员#
| 接口 | 描述 |
|---|
| UnaryOperator<T> | 提供单个类型参数,并且返回一个与输入参数类型一致的结果 |
| BinaryOperator<T> | 提供两个相同类型参数,并且返回结果与输入参数类型一致的结果 |
| DoubleBinaryOperator | 提供两个double参数并且返回double结果 |
| DoubleUnaryOperator | 提供单个double参数并且返回double结果 |
| IntBinaryOperator | 提供两个int参数并且返回int结果 |
| IntUnaryOperator | 提供单个int参数并且返回int结果 |
| LongBinaryOperator | 提供两个long参数并且返回long结果 |
| LongUnaryOperator | 提供单个long参数并且返回long结果 |
常用操作#
求最大最小值#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| List<BigDecimal> decimalList = Arrays.asList(
new BigDecimal("1"),
new BigDecimal("2"),
new BigDecimal("3"),
new BigDecimal("-10"),
null,
new BigDecimal("0")
);
//过滤null,并取最大值
Optional<BigDecimal> max = decimalList.stream().filter(Objects::nonNull).max(BigDecimal::compareTo);
if (max.isPresent()) {
BigDecimal maxdecimal = max.get();
}
//过滤null,并取最小值
Optional<BigDecimal> min = decimalList.stream().filter(Objects::nonNull).max(BigDecimal::compareTo);
if (max.isPresent()) {
BigDecimal mindecimal = max.get();
}
|
求decimal积#
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
| List<BigDecimal> decimalList = List.of(
new BigDecimal("1"),
new BigDecimal("2"),
new BigDecimal("3"),
null,
new BigDecimal("-10"),
new BigDecimal("0")
);
//求decimalList所有元素乘积,并忽略null元素
String res = decimalList.stream().collect(Collector.of(
() -> new BigDecimal[1],
(a, t) -> {
if (a[0] == null) {
a[0] = BigDecimal.ONE;
}
if (t != null && t.compareTo(BigDecimal.ZERO) != 0) {
a[0] = a[0].multiply(t);
}
},
(a1, a2) -> {
a1[0] = a1[0].multiply(a2[0]);
return a1;
},
(a) -> a[0].toString()
));
|
切分list#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| List<String> arr=new ArrayList<>();
for (int i = 0; i < 10950; i++) {
arr.add(String.valueOf(i));
}
int step = 100;
List<List<String>> lists = Stream.iterate(0L, n -> n + 1L) //返回一个无限有序流 0123456.......
.limit((arr.size() + step - 1) / step) //指定最后返回的 list大小,
.parallel() //转换并行流
.map(a -> arr.stream().skip(a * step)
.limit(step).parallel() //转换为并行流并进行归约
.collect(Collectors.toList()))
.collect(Collectors.toList());
|