java8函数式编程（四）

相关链接：

java8函数式编程（一）
java8函数式编程（二）
java8函数式编程（三）

  其中（一）是在没有开始了解java8新特性之前实际遇到的一个问题，使用for循环实现的代码很繁琐，于是尝试使用新的编码风格，最后很不完美的实现了需求。在进一步学习后，在（二）中完美实现，并对List常用的操作做了一个总结。最后在（三）中对并行化流与并行化数组的操作简单归纳。
  本节主要是对java8流处理一个总结以及一些细节的补充。另外，学习资料主要参考《Java8实战》与《Java8函数式编程》两本书籍。

---

Stream API

优点：

1 声明性 – 简洁、易读
2 可复合 – 灵活组合
3 可并行 – 高性能

常用操作:
1 筛选
filter  过滤
distinct  去重
limit   截断
skip   跳过
2 映射
map   转换
flatMap   扁平化转换
3 查找与匹配
anyMatch   至少有一个满足
allMatch   所有都满足
noneMatch   没有一个满足
findAny   返回任意一个
findFrist   返回第一个
4 归约
reduce   计算
count   元素个数
5 数值流
mapToInt     IntStream
mapToDouble  DoubleStream
max    最大
min    最小
average   平均
boxed   数值流装箱
range   范围内(不包括end)
reageClosed  范围内(包括end)
6 构建流
of
iterate
generate
7 收集器
collect

数值操作

从1到20间的奇数

IntStream.rangeClosed(1, 20)
                .filter(n -> n%2 != 0)
                .forEach(System.out::println);

100以内奇数的和

int sum = IntStream.range(1, 100)
                .filter(n -> n % 2 != 0)
                .sum();

斐波那契数列（前20位）

Stream.iterate(new int[]{0,1}, n -> new int[]{n[1], n[0] + n[1]})
                .limit(20)
                .map(n -> n[0])
                .forEach(System.out::println);

collect收集器

准备数据依然使用List<Frog>，frog的属性有name名称，age年龄，color颜色，size体积。

        List<Frog> list = new ArrayList<>();
        list.add(new Frog("one", 2 , "red", 5.1));
        list.add(new Frog("two", 3 , "red", 5.0));
        list.add(new Frog("three", 2 , "blue", 5.5));
        list.add(new Frog("four", 1 , "blue", 5.3));
        list.add(new Frog("five", 5 , "yellow", 5.1));
        list.add(new Frog("six", 3 , "yellow", 5.2));

collect方法参数Collector。Collector接口中方法实现对流执行的操作，Collectors实现类提供很多静态方法，下面是对这些静态方法的说明。
为了代码简洁，导入Collectors类中所有方法：

import static java.util.stream.Collectors.*;

summaryStatistics

该方法可以一次性获取到数量、总和、最大值、最小值和平均数

DoubleSummaryStatistics summaryStatistics = frogs.stream()
                .collect(summarizingDouble(Frog::getSize));
System.out.println(summaryStatistics);

打印结果

DoubleSummaryStatistics{count=6, sum=31.200000, min=5.000000, average=5.200000, max=5.500000}

也可以直接通过summaryStatistics 的getter方法获取某一项。

joining

字符串的连接，方法重载

String names = frogs.stream()
                .map(Frog::getName)
                .collect(joining(" ", "[", "]"));

打印结果

[one two three four five six]

groupingBy

1、分组与多级分组

Map<String, List<Frog>> map = frogs.stream()
                .collect(groupingBy(Frog::getColor));

Map<String, Map<Volume, List<Frog>>> map1 = frogs.stream()
                .collect(groupingBy(Frog::getColor,
                        groupingBy(frog -> {
                            if (frog.getSize() < 5.2) {
                                return Volume.SMALL;
                            } else {
                                return Volume.BIG;
                            }
                        })));
                    
public enum Volume {
        BIG,
        SMALL
}

打印结果

{
 red=[Frog{name='one', age=2, color='red', size=5.1}, Frog{name='two', age=3, color='red', size=5.0}],
 blue=[Frog{name='three', age=2, color='blue', size=5.5}, Frog{name='four', age=1, color='blue', size=5.3}],
 yellow=[Frog{name='five', age=5, color='yellow', size=5.1}, Frog{name='six', age=3, color='yellow', size=5.2}]
 }

{
 red={
 	SMALL=[Frog{name='one', age=2, color='red', size=5.1}, Frog{name='two', age=3, color='red', size=5.0}]
 	},
 blue={
 	BIG=[Frog{name='three', age=2, color='blue', size=5.5}, Frog{name='four', age=1, color='blue', size=5.3}]
 	}, 
 yellow={
 	BIG=[Frog{name='six', age=3, color='yellow', size=5.2}], 
 	SMALL=[Frog{name='five', age=5, color='yellow', size=5.1}]
 	}
}

groupingBy第二个参数可以使用mapping方法。例：

Map<String, HashSet<Volume>> map4 = frogs.stream()
                .collect(groupingBy(Frog::getColor,
                        mapping(frog -> {
                            if (frog.getSize() < 5.2) {
                                return Volume.SMALL;
                            } else {
                                return Volume.BIG;
                            }
                        }, toCollection(HashSet::new))));

2、分组后的数据操作，比如按颜色分组，求每组中size最大的元素

Map<String, Frog> map2 = frogs.stream()
                .collect(groupingBy(Frog::getColor,
                        collectingAndThen(minBy(Comparator.comparingDouble(Frog::getSize)), Optional::get)));

等价的写法

Map<String, Frog> map3 = frogs.stream()
                .collect(toMap(Frog::getColor,
                        Function.identity(),
                        BinaryOperator.minBy(Comparator.comparingDouble(Frog::getSize))));

Function.identity()：返回一个总是返回其输入参数的函数

partitioningBy

分区，分组的特殊情况，将数据分为true和false两组

Map<Boolean, Long> map = frogs.stream()
                .collect(partitioningBy(t -> t.getAge() > 1, counting()));

打印结果

{false=1, true=5}

实践

项目中遇到一个两级分组的问题，需要先按名称分组，然后再按标志（0/1）分组，对分组后的数量求和（库里String类型，实际需要按double类型求和）。代码如下：

Map<String, Map<String, Double>> map = list.stream()
                .collect(Collectors.groupingBy(Frog::getMc,
                        Collectors.groupingBy(Frog::getBz,
                                Collectors.summingDouble(t -> Double.parseDouble(t.getSl())))));

上面写法有一个计算精度问题，于是改成了一下方式：

Map<String, Map<String, BigDecimal>> map = list.stream()
                .collect(Collectors.groupingBy(Frog::getMc,
                        Collectors.groupingBy(Frog::getBz,
                                Collectors.reducing(new BigDecimal(0),
                                        t -> new BigDecimal(t.getSl()),
                                        (BigDecimal a, BigDecimal b) -> a.add(b)))));

用BigDecimal类型求和后精度是没有问题的，初除此之外还能对结果进行一些处理，比如保留两位小数（四舍五入）

BigDecimal number = new BigDecimal();
number.setScale(2,BigDecimal.ROUND_HALF_UP);

BigDecimal更多用法可以参考：
博主：星朝
链接：BigDecimal的用法详解(保留两位小数,四舍五入,数字格式化，科学计数法转数字，数字里的逗号处理）