JAVA8 Stream流之reduce()方法详解
JAVA8 Stream流之reduce()方法详解
reduce()简介
Reduce
原意:减少,缩小- 根据指定的计算模型将Stream中的值计算得到一个最终结果
解释:reduce 操作可以实现从Stream中生成一个值,其生成的值不是随意的,而是根据指定的计算模型。比如,之前提到count、min和max方法,因为常用而被纳入标准库中。事实上,这些方法都是reduce操作。
reduce三个override的方法
reduce方法有三个override的方法:
Optional
reduce(BinaryOperator accumulator);
T reduce(T identity, BinaryOperator
accumulator);
<U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner);
公共集合
测试代码中的所有集合,都是该集合。
List<Person> javaProgrammers = new ArrayList<Person>() {
{
add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 2000, 18));
add(new Person("Tamsen", "Brittany", "Java programmer", "female", 2371, 55));
add(new Person("Floyd", "Donny", "Java programmer", "male", 3322, 25));
add(new Person("Sindy", "Jonie", "Java programmer", "female", 35020, 15));
add(new Person("Vere", "Hervey", "Java programmer", "male", 2272, 25));
add(new Person("Maude", "Jaimie", "Java programmer", "female", 2057, 87));
add(new Person("Shawn", "Randall", "Java programmer", "male", 3120, 99));
add(new Person("Jayden", "Corrina", "Java programmer", "female", 345, 25));
add(new Person("Palmer", "Dene", "Java programmer", "male", 3375, 14));
add(new Person("Addison", "Pam", "Java programmer", "female", 3426, 20));
}
};
方式一reduce(BinaryOperator accumulator)
Optional<T> reduce(BinaryOperator<T> accumulator);
我们先看第一个变形,参数列表为一个函数接口BinaryOperator<T>
,
BinaryOperator源码:
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
}
public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
}
}
看BinaryOperator接口源码,我们可以看到,它又继承了 BiFunction<T,T,T>
.
另外,在BinaryOperator
接口中又定义了另个静态方法为minBy和maxBy
,
上面我们提到BinaryOperator接口继承了BiFunction<T,T,T>
,我们看一下BiFunction<T,T,T>
源码:
@FunctionalInterface
public interface BiFunction<T, U, R> {
R apply(T t, U u);//接收两个参数 t 和 u, 返回 R
}
Bifunction
中有一个apply
方法,接收两个参数,返回一个结果
小结: 不管是BinaryOperator类还是最终继承的BiFunction类,在类上都有@FunctionalInterface
注解,因此reduce(BinaryOperator<T> accumulator)方法需要一个函数式接口参数
,该函数式接口需要两个参数
,返回一个结果
(reduce中返回的结果会作为下次累加器计算的第一个参数),也就是累加器
,最终得到一个Optional对象
测试示例代码:
@Test
public void Test() {
int asInt = javaProgrammers.stream()
.mapToInt(Person::getSalary)//返回数值流,减少拆箱封箱操作,避免占用内存 IntStream
.reduce((x, y) -> x += y)// int
.getAsInt(); //return int
System.out.printf("方式一 reduce(BinaryOperator<T> accumulator) 求薪资测试结果:"+asInt);
/*解析:
1. reduce(BinaryOperator<T> accumulator) reduce方法接受一个函数,这个函数有两个参数
2. 第一个参数是上次函数执行的返回值(也称为中间结果),第二个参数是stream中的元素,这个函数把这两个值相加,得到的和会被赋值给下次执行这个函数的第一个参数
*注意:
1.第一次执行的时候第一个参数的值是Stream的第一个元素,第二个参数是Stream的第二个元素
2.方法返回值类型是Optional
*/
}
方式二reduce(T identity, BinaryOperator accumulator)
T reduce(T identity, BinaryOperator<T> accumulator);
与第一种变形相同的是都会接受一个BinaryOperator
函数接口,不同的是其会接受一个identity参数
,identity参数与Stream中数据同类型,相当于一个的初始值
,通过累加器accumulator迭代计算Stream中的数据
,得到一个跟Stream中数据相同类型的最终结果。
测试示例代码:
@Test
public void test1(){
int reduce = javaProgrammers.stream().mapToInt(Person::getSalary).reduce(10000, (x, y) -> x += y);
System.out.printf("方式二 reduce(T identity, BinaryOperator<T> accumulator) 求薪资测试结果:"+reduce);
/*注意:
* 1.与方式一相比设置了累加器的初始值,参数一(x)则不再是Stream中的第一个数据而是设置的初始值(10000)其他相同
*/
}
打印结果:
方式一 reduce(BinaryOperator<T> accumulator) 求薪资测试结果:57308
方式二 reduce(T identity, BinaryOperator<T> accumulator) 求薪资测试结果:67308 //初始值10000
方式三 reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner)
\<U\> U reduce(U identity,BiFunction\<U, ? super T, U\> accumulator,BinaryOperator\<U\> combiner);
我们先观察分析再次被改变的参数列表:
\(~~~~~~~\) 1. 第一个参数:返回实例u,传递你要返回的U类型对象的初始化实例u
\(~~~~~~~\) 2. 第二个参数:累加器accumulator,可以使用lambda表达式,声明你在u上累加你的数据来源t的逻辑,例如(u,t)->u.sum(t),此时lambda表达式的行参列表是返回实例u和遍历的集合元素t,函数体是在u上累加t
\(~~~~~~~\) 3. 第三个参数:参数组合器combiner,接受lambda表达式。
根据参数我们一步一步分析代码示例:
@Test
public void test2() {
ArrayList<Integer> accResult_ = Stream.of(1, 2, 3, 4)
//第一个参数,初始值为ArrayList
.reduce(new ArrayList<Integer>(),
//第二个参数,实现了BiFunction函数式接口中apply方法,并且打印BiFunction
new BiFunction<ArrayList<Integer>, Integer, ArrayList<Integer>>() {
@Override
public ArrayList<Integer> apply(ArrayList<Integer> acc, Integer item) {
acc.add(item);
System.out.println("item: " + item);
System.out.println("acc+ : " + acc);
System.out.println("BiFunction");
return acc;
}
//第三个参数---参数的数据类型必须为返回数据类型,改参数主要用于合并多个线程的result值
// (Stream是支持并发操作的,为了避免竞争,对于reduce线程都会有独立的result)
}, new BinaryOperator<ArrayList<Integer>>() {
@Override
public ArrayList<Integer> apply(ArrayList<Integer> acc, ArrayList<Integer> item) {
System.out.println("BinaryOperator");
acc.addAll(item);
System.out.println("item: " + item);
System.out.println("acc+ : " + acc);
System.out.println("--------");
return acc;
}
});
System.out.println("accResult_: " + accResult_);
System.out.println("------------------lambda优化代码-----------------");
ArrayList<Integer> newList = new ArrayList<>();
ArrayList<Integer> accResult_s = Stream.of(1,2,3,4)
.reduce(newList,
(acc, item) -> {
acc.add(item);
System.out.println("item: " + item);
System.out.println("acc+ : " + acc);
System.out.println("BiFunction");
return acc;
}, (acc, item) -> null);
System.out.println("accResult_s: " + accResult_s);
/**
*注意:
* 1. 方式三:第三个参数用来处理并发操作,如何处理数据的重复性,应多做考虑,否则会出现重复数据!
* 2. 方式三:只有在使用静态Stream类of创建的Stream流对象,才会是有使用该方式
*
*/
}
\(~~~~\)示例代码中,第一个参数是ArrayList
,在第二个函数参数中打印了“BiFunction”,而在第三个参数接口中打印了函数接口中打印了”BinaryOperator“.看下面的打印结果,只打印了“BiFunction”,而没有打印”BinaryOperator“,也就是说第三个函数参数并没有执行。分析参数时我们知道了该变形可以返回任意类型的数据
。
\(~~~~\)对于第三个函数参数,为什么没有执行,而且其参数必须为返回的数据类型?这是因为Stream是支持并发操作的,为了避免竞争,对于reduce线程都会有独立的result,combiner的作用在于合并每个线程的result得到最终结果。这也说明了了第三个函数参数的数据类型必须为返回数据类型了。
java8 reduce方法中的第三个参数combiner有什么作用?
打印结果:
item: 1
acc+ : [1]
BiFunction
item: 2
acc+ : [1, 2]
BiFunction
item: 3
acc+ : [1, 2, 3]
BiFunction
item: 4
acc+ : [1, 2, 3, 4]
BiFunction
另外需要注意:因为第三个参数用来处理并发操作,如何处理数据的重复性,应多做考虑,否则会出现重复数据!
结束语
路漫漫其修远行,吾将上下而求索
推荐参考博客:
https://blog.csdn.net/IO_Field/article/details/54971679
https://blog.csdn.net/weixin_43860260/article/details/94875064
原文地址:https://www.cnblogs.com/MrYuChen-Blog/p/14061320.html
- MS Enterprise Library 5.0发布!!
- WCF技术剖析之二十二: 深入剖析WCF底层异常处理框架实现原理[中篇]
- 《Enterprise Library深入解析与灵活应用》博文系列汇总
- 使命必达: 深入剖析WCF的可靠会话[概念篇]
- AngularJS in Action读书笔记2——view和controller的那些事儿
- WCF技术剖析之二十一:WCF基本异常处理模式[中篇]
- 小程序上线“小游戏”,正式引爆3.0社交红利
- 漫谈人工智能机器翻译的前世今生
- 并发与实例上下文模式: WCF服务在不同实例上下文模式下具有怎样的并发表现
- 区块链将变革的五个行业
- WCF技术剖析之二十三:服务实例(Service Instance)生命周期如何控制[上篇]
- AngularJS in Action读书笔记3——走近Services
- 有了这些无人驾驶的汽车,未来还需要考驾照吗?
- 并发与实例上下文模式: WCF服务在不同实例上下文模式下具有怎样的并发表现
- java教程
- Java快速入门
- Java 开发环境配置
- Java基本语法
- Java 对象和类
- Java 基本数据类型
- Java 变量类型
- Java 修饰符
- Java 运算符
- Java 循环结构
- Java 分支结构
- Java Number类
- Java Character类
- Java String类
- Java StringBuffer和StringBuilder类
- Java 数组
- Java 日期时间
- Java 正则表达式
- Java 方法
- Java 流(Stream)、文件(File)和IO
- Java 异常处理
- Java 继承
- Java 重写(Override)与重载(Overload)
- Java 多态
- Java 抽象类
- Java 封装
- Java 接口
- Java 包(package)
- Java 数据结构
- Java 集合框架
- Java 泛型
- Java 序列化
- Java 网络编程
- Java 发送邮件
- Java 多线程编程
- Java Applet基础
- Java 文档注释
- android 9.0 launcher3 去掉抽屉式显示所有 app(代码详解)
- 图论-多源最短路径(Floyd算法)
- Android9.0 SystemUI 网络信号栏定制修改的流程解析
- 解决Android 10/Android Q手机在后台无法正常定位问题
- C语言CGI编程入门(一)
- android RecycleView实现下拉刷新和上拉加载
- 解析Android 8.1平台SystemUI 导航栏加载流程
- Mysql系列第二十二讲 mysql索引管理详解
- Android自定义View实现五子棋小游戏
- 通过.htaccess防盗链
- Android实现聊天记录上传本地服务器(即时通讯)
- Android10.0实现本地音乐播放(附源码下载)
- python - 获取网站PR及百度权重
- 详解Android Studio3.5及使用AndroidX的一些坑
- AndroidQ分区存储权限变更及适配的实现