JAVA 8 收集器 使用

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;
        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;
            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;
            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;
            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) {