JAVA 8 收集器(Collectors) 使用
收集器功能：1.将流元素归约和汇总 2.元素分组 3.元素分区
都是 import static java.util.stream.Collectors.*; 前提下
一、归约和汇总
1. 查找最大最小值
maxBy(Comparator)
minBy(Comparator)
2. 汇总
求和:
summingInt(XX::getX)
summingLong(XX::getX)
summingDouble(XX::getX)
求平均值:
averagingInt(XX::getX)
averagingDouble(XX::getX)
averagingLong(XX::getX)
综合方法，和，平均，最大最小全求出来:
summarizingInt(XX:getX)
summarizingDouble(XX:getX)
summarizingLong(XX:getX)
3. 连接字符串
joining() --内部使用StringBuffer拼接
joining(", ") --可以添加参数，用什么隔开
4. 广义的归约汇总
reducing(M,N,W) 需要3个参数
M -> 初始值
N -> XX::getX
W -> 一个lamda转换函数
reducing(W) 可以一个参数
W -> 一个Lambda转换函数
二、分组
Collectors.groupingBy()
1.简单分组
Collectors.groupingBy(W) W为一个Lambda
public enum Level { LOW, NORMAL, HIGH };
Map<Integer, List<Transaction>> maps = trans.parallelStream().collect(groupingBy(Transaction::getValue));
//返回的是Key
Map<Level, List<Transaction>> maps2 = trans.parallelStream().collect(groupingBy(t -> {
if (t.getValue() <= 500)
return Level.LOW;
else if (t.getValue() <= 1000)
return Level.NORMAL;
else
return Level.HIGH;
}));
2.多级分组
多级就是类似按照这一级规则分完组，继续按照下个规则继续分组，将内存传递给外层
即为groupingBy套用groupingBy
Collectors.groupingBy(W, groupingBy(M)) W为一个分类函数 M可以为任何类型
Map<Integer, Map<Level, List<Transaction>>> maps3 = trans.parallelStream()
.collect(groupingBy(Transaction::getYear, groupingBy(t -> {
if (t.getValue() <= 500)
return Level.LOW;
else if (t.getValue() <= 1000)
return Level.NORMAL;
else
return Level.HIGH;
})));
3.按子组收集数据
传递给groupingBy的第二个收集器可以是==任何类型==
普通的单函数groupingBy(f) 实际上为 groupingBy(f, toList())
Map<Integer, Optional<T>> maps4 = trans.stream().collect(groupingBy(T::getYear,
maxBy(Comparator.comparingInt(T::getValue))));
3.1 把收集器结果转换为另一种类型
Collectors.collectingAndThen(W,M) 返回一个收集器
W：要转换的收集器 M：转换函数
Map<Integer, Transaction> maps5 = trans.stream().collect(groupingBy(Transaction::getYear,
collectingAndThen(maxBy(comparing(Transaction::getValue)), Optional::get)));
3.2 于groupingBy联合使用的其他收集器
Collectors.mapping(W,M) 返回一个收集器
W：转换函数 M：收集函数
这里是先将值映射为Level，将生成的Level流传给toSet，然后返回:
Map<Integer, Set<Level>> maps7 = trans.stream()
.collect(groupingBy(Transaction::getYear, Collectors.mapping(t -> {
if (t.getValue() <= 500)
return Level.LOW;
else if (t.getValue() <= 1000)
return Level.NORMAL;
else
return Level.HIGH;
}, toSet())));
Map<Integer, Set<Level>> maps7 = trans.stream()
.collect(groupingBy(Transaction::getYear, Collectors.mapping(t -> {
if (t.getValue() <= 500)
return Level.LOW;
else if (t.getValue() <= 1000)
return Level.NORMAL;
else
return Level.HIGH;
}, Collectors.toCollection(HashSet::new))));
Collectors.toCollection(HashSet::new) 可以控制其生成的流的类型
三、分区
1. 分区
Collectors.partitioningBy(W) W必须为返回boolean值的函数
Collectors.partitioningBy(W,M) W必须为返回boolean值的函数 M为收集器
直接按照某boolean值分区 true|false
Map<Boolean, List<Transaction>> map1 = trans.stream().collect(Collectors.partitioningBy(Transaction::getIsOk));
可以添加收集器参数
Map<Boolean, Map<Integer, List<Transaction>>> map2 = trans.stream()
.collect(Collectors.partitioningBy(Transaction::getIsOk, groupingBy(Transaction::getYear)));
可以使用collectingAndThen来完成连续收集功能
Map<Boolean, Transaction> map3 = trans.stream().collect(Collectors.partitioningBy(Transaction::getIsOk,
collectingAndThen(maxBy(Comparator.comparing(Transaction::getValue)), Optional::get)));
2.按照质数非质数分区
private boolean isPrime(int num) {
int num2 = (int) Math.sqrt((double) num);
return IntStream.rangeClosed(2, num2).noneMatch(t -> num % t == 0);
}
private Map<Boolean, List<Integer>> getNum(int n) {
return IntStream.rangeClosed(2, n).boxed().collect(Collectors.partitioningBy(t -> isPrime(t)));
}
Map<Boolean, List<Integer>> map4 = getNum(N);
