java8 stream reduce_java8集合Stream之reduce聚合函数——看这篇就够了
说明
java8集合中Stream()相关函数都支持lambda表达式，reduce()就是其中之一，
reduce是一种聚合操作，聚合的含义就是将多个值经过特定计算之后得到单个值，
常见的 count 、sum 、avg 、max 、min 等函数就是一种聚合操作。
本文使用reduce函数做求和计算来说明它的用法：
reduce有三个重载方法
1.一个参数的reduce
Optionalreduce(BinaryOperatoraccumulator);
参数： BinaryOperatoraccumulator , BinaryOperator 继承于 BiFunction, 这里实现 BiFunction.apply(param1,param2) 接口即可。支持lambda表达式，形如：(result,item)->{...} 。
返回值：返回Optional对象，由于结果存在空指针的情况(当集合为空时)因此需要使用Optional。
如下代码通过reduce 求整数集合中的元素之和：
import com.google.common.collect.Lists;
import java.util.List;
public class LambdaTest {
public static void main(String[] args) {
List list=Lists.newArrayList(1,2,3,4,5);
//将数组进行累加求和
//由于返回的是 Optional ，因此需要get()取出值。
Integer total=list.stream().reduce((result,item)->result+item).get();
System.out.println(total);
}
}
//结果为： 15
将累加的每一步打印，可以发现Lambda表达式中的两个参数(result,item)的含义：
第一个参数 result ：初始值为集合中的第一个元素，后面为每次的累加计算结果 ；
第二个参数 item ：遍历的集合中的每一个元素(从第二个元素开始，第一个被result使用了)。
List list=Lists.newArrayList(1,2,3,4,5);
list.stream().reduce((result,item)->{
System.out.println("result="+result+", item="+item);
return result+item;
});
/* 结果如下：
result=1, item=2
result=3, item=3
result=6, item=4
result=10, item=5
*/
2.两个参数的reduce
T reduce(T identity, BinaryOperatoraccumulator);
参数1：T identity 为一个初始值(默认值) ，当集合为空时，就返回这个默认值，当集合不为空时，该值也会参与计算；
参数2：BinaryOperatoraccumulator 这个与一个参数的reduce相同。
返回值：并非 Optional，由于有默认值 identity ，因此计算结果不存在空指针的情况。
List list=Lists.newArrayList(1,2,3,4,5);
Integer total=list.stream().reduce(0,(result,item)->result+item);
System.out.println(total);//结果为：15
list=new ArrayList<>();
total=list.stream().reduce(0,(result,item)->result+item);
System.out.println(total);//数组为空时，结果返回默认值0
3.三个参数的reduce
U reduce(U identity, BiFunctionaccumulator,BinaryOperatorcombiner);
第一个参数和第二个参数的定义同上，第三个参数比较特殊，后面慢慢讲。
可以看到该方法有两个泛型 T 和 U ：
(1)泛型T是集合中元素的类型，
(2)泛型U是计算之后返回结果的类型，U的类型由第一个参数 identity 决定。
也就是说，三个参数的reduce()可以返回与集合中的元素不同类型的值，方便我们对复杂对象做计算式和转换。
而一个参数和两个参数的reduce()只能返回与集合中的元素同类型的值。
现在我们在集合中存放 ScoreBean 对象，模拟学生分数统计：
static class ScoreBean {
private String name; //学生姓名
private int score; //分数，需要汇总该字段
public ScoreBean(String name, int score) {
this.name = name;
this.score = score;
}
//get 和 set 方法省略
}
我们对 ScoreBean 中 score 字段汇总：(后面示例代码中的list定义省略，都用这个)
List list= Lists.newArrayList(
new ScoreBean("张三",1)
,new ScoreBean("李四",2)
,new ScoreBean("王五",3)
,new ScoreBean("小明",4)
,new ScoreBean("小红",5));
Integer total=list.stream()
.reduce(
Integer.valueOf(0) /*初始值 identity*/
,(integer,scoreBean)->integer+scoreBean.getScore() /*累加计算 accumulator*/
,(integer1,integer2)->integer1+integer2 /*第三个参数 combiner*/
);
System.out.println(total);//结果：15
其实这个相当于：
Integer total=list.stream().mapToInt(ScoreBean::getScore).sum();
System.out.println(total);//结果也是：15
第三个参数 BinaryOperatorcombiner 是个什么鬼？
这个参数的lambda表达式我是这么写的：(integer1,integer2)->integer1+integer2)
现在我将其打印出来：
Integer total=list.stream()
.reduce(
Integer.valueOf(0)
,(integer,scoreBean)->integer+scoreBean.getScore()
,(integer1,integer2)->{
//这个println居然没有执行！！！
System.out.println("integer1="+integer1+", integer2="+integer2);
return integer1+integer2;
}
);
发现这个参数的lambda表达式根本就没有执行？！
我换了一种方式，换成 parallelStream ，然后把线程id打印出来：
//Integer total=list.stream()
Integer total=list.parallelStream()
.reduce(
Integer.valueOf(0)
,(integer,scoreBean)->integer+scoreBean.getScore()
,(integer1,integer2)->{
//由于用的 parallelStream ，可发生并行计算，所以我增加线程id的打印：
System.out.println("threadId="+Thread.currentThread().getId()+", integer1="+integer1+", integer2="+integer2);
return integer1+integer2;
}
);
/*结果如下：
threadId=13, integer1=1, integer2=2
threadId=1, integer1=4, integer2=5
threadId=1, integer1=3, integer2=9
threadId=1, integer1=3, integer2=12
*/
把 stream 换成并行的 parallelStream，
可以看出，有两个线程在执行任务：线程13和线程1 ，
每个线程会分配几个元素做计算，
如上面的线程13分配了元素1和2，线程1分配了3、4、5。
至于线程1为什么会有两个3，是由于线程13执行完后得到的结果为3(1+2)，而这个3又会作为后续线程1的入参进行汇总计算。
可以多跑几次，每次执行的结果不一定相同，如果看不出来规律，可以尝试增加集合中的元素个数，数据量大更有利于并行计算发挥作用。
因此，第三个参数 BinaryOperatorcombiner 的作用为：汇总所有线程的计算结果得到最终结果。
并行计算会启动多个线程执行同一个计算任务，每个线程计算完后会有一个结果，最后要将这些结果汇总得到最终结果。
我们再来看一个有意思的结果，把第一个参数 identity 从0换成1：
//Integer total=list.stream()
Integer total=list.parallelStream()
.reduce(
Integer.valueOf(1)
,(integer,scoreBean)->{
System.out.println("$ threadId="+Thread.currentThread().getId()+", integer="+integer+", scoreBean.getScore()="+scoreBean.getScore());
return integer+scoreBean.getScore();
}
,(integer1,integer2)->{
System.out.println("threadId="+Thread.currentThread().getId()+", integer1="+integer1+", integer2="+integer2);
return integer1+integer2;
}
);
System.out.println("result="+total);
/* 运行结果如下：
$ threadId=12, integer=1, scoreBean.getScore()=2
$ threadId=1, integer=1, scoreBean.getScore()=3
$ threadId=14, integer=1, scoreBean.getScore()=5
$ threadId=13, integer=1, scoreBean.getScore()=1
$ threadId=15, integer=1, scoreBean.getScore()=4
threadId=13, integer1=2, integer2=3
threadId=15, integer1=5, integer2=6
threadId=15, integer1=4, integer2=11
threadId=15, integer1=5, integer2=15
result=20
*/
预期结果应该是16(初始值1+原来的结果15)，但实际结果为20，多加了4次1，猜测是多加了四次初始值，
从打印的结果可以发现：
(1)并行计算时用了5个线程(线程id依次为：12, 1, 14, 13, 15)，汇总合并时用了两个线程(线程id为13和15)
(2)并行计算的每一个线程都用了初始值参与计算，因此多加了4次初始值。
总结：
使用 parallelStream 时，初始值 identity 应该设置一个不影响计算结果的值，比如本示例中设置为 0 就不会影响结果。
我觉得这个初始值 identity 有两个作用：确定泛型U的类型 和 避免空指针。
但是如果初始值本身就是一个复杂对象那该怎么办呢？
比如是初始值是一个数组，那么应该设定为一个空数组。如果是其他复杂对象那就得根据你reduce的具体含义来设定初始值了。
用表达式来解释就是初始值identity应该满足以下等式：
combiner.apply(u, accumulator.apply(identity, t)) == accumulator.apply(u, t)
//combiner.apply(u1,u2) 接收两个相同类型U的参数
//accumulator.apply(u, t) 接收两个不同类型的参数U和T，U是返回值的类型，T是集合中元素的类型
//这个等式恒等，parallelStream计算时就不会产生错误结果