标签：combiner Collectors Stream 收集器 System accumulator result println Collector
一、Stream收集器 Collector接口
package com.java.design.java8.Stream;
import com.java.design.java8.entity.Student;
import com.java.design.java8.entity.Students;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author 陈杨
*/
@SpringBootTest
@RunWith(SpringRunner.class)
public class CollectorDetail {
private List<Student> students;
@Before
public void init() {
students=new Students().init();
}
@Test
public void testCollectorDetail() {
// Collect 收集器 ---- Collector接口
// T-->汇聚操作的元素类型 即流中元素类型
// A-->汇聚操作的可变累积类型
// R-->汇聚操作的结果类型
// public interface Collector<T, A, R>
// Collector接口 一种可变汇聚操作
// 将输入元素累积到可变结果容器中
// 在处理完所有输入元素后 可以选择将累积的结果转换为最终表示（可选操作）
// 归约操作支持串行与并行
// A mutable reduction operation that accumulates input elements into a mutable result container,
// optionally transforming the accumulated result into a final representation after all input elements
// have been processed. Reduction operations can be performed either sequentially or in parallel.
// Collectors 提供 Collector 汇聚实现 实际上是一个Collector工厂
// The class {@link Collectors} provides implementations of many common mutable reductions.
二、Collector 接口组成
// Collector 由以下4个函数协同累积到容器 可选的执行最终转换
// supplier 创建一个新的结果容器
// accumulator累加器 将新数据元素合并到结果容器中
// combiner 合并结果容器 处理线程并发
// finisher 对容器执行可选的最终转换
//
// A {@code Collector} is specified by four functions that work together to
// accumulate entries into a mutable result container, and optionally perform
// a final transform on the result. They are:
// creation of a new result container ({@link #supplier()})
// incorporating a new data element into a result container ({@link #accumulator()})
// combining two result containers into one ({@link #combiner()})
// performing an optional final transform on the container ({@link #finisher()})三、combiner
/*
* A function that accepts two partial results and merges them. The
* combiner function may fold state from one argument into the other and
* return that, or may return a new result container.
*
*
* BinaryOperator<A> combiner();
*/
/* supplier创建单个结果容器-->accumulator调用累积功能-->partition结果--分区容器-->combiner合并分区容器
A sequential implementation of a reduction using a collector would
create a single result container using the supplier function, and invoke the
accumulator function once for each input element. A parallel implementation
would partition the input, create a result container for each partition,
accumulate the contents of each partition into a subresult for that partition,
and then use the combiner function to merge the subresults into a combined
result.
*/四、identity associativity 约束
/*
确保串行与并行结果的一致性，满足约束： identity associativity
To ensure that sequential and parallel executions produce equivalent
results, the collector functions must satisfy an identity and an associativity constraints.
*/
/* identity 约束：
对于任何部分累积的结果， 将其与空结果容器组合必须生成等效的结果
a == combiner.apply(a, supplier.get())
The identity constraint says that for any partially accumulated result,
combining it with an empty result container must produce an equivalent
result. That is, for a partially accumulated result {@code a} that is the
result of any series of accumulator and combiner invocations, {@code a} must
be equivalent to {@code combiner.apply(a, supplier.get())}.
*/
/* associativity 约束：
串行计算与并行拆分计算必须产生同等的结果
The associativity constraint says that splitting the computation must
produce an equivalent result. That is, for any input elements {@code t1}
and {@code t2}, the results {@code r1} and {@code r2} in the computation
below must be equivalent:
A a1 = supplier.get();
accumulator.accept(a1, t1);
accumulator.accept(a1, t2);
R r1 = finisher.apply(a1); // result without splitting
A a2 = supplier.get();
accumulator.accept(a2, t1);
A a3 = supplier.get();
accumulator.accept(a3, t2);
R r2 = finisher.apply(combiner.apply(a2, a3)); // result with splitting
*/五、reduction 汇聚 的实现方式
// reduction 汇聚 的实现方式
// list.stream().reduce() 对象不可变
// list.stream().collect(Collectors.reducing()) 对象可变
// 单线程可以实现结果一致 但在多线程中就会出现错误
/*
Libraries that implement reduction based on {@code Collector}, such as
{@link Stream#collect(Collector)}, must adhere to the following constraints:
传递给accumulator的第一个参数，传递给combiner的二个参数，传递给finisher的参数
必须是函数（supplier accumulator combiner）上一次调用结果
理解： 参数类型A
Supplier<A> supplier();
BiConsumer<A, T> accumulator();
BinaryOperator<A> combiner();
Function<A, R> finisher();
The first argument passed to the accumulator function, both
arguments passed to the combiner function, and the argument passed to the
finisher function must be the result of a previous invocation of the
result supplier, accumulator, or combiner functions
supplier accumulator combiner的实现结果-->
传递给下一次supplier accumulator combiner操作
或返还给汇聚操作的调用方
而不进行其他操作
The implementation should not do anything with the result of any of
the result supplier, accumulator, or combiner functions other than to
pass them again to the accumulator, combiner, or finisher functions,
or return them to the caller of the reduction operation
一个结果传递给combiner finisher而相同的对象没有从此函数中返回 这个结果不会再被使用
这个传入结果是被消费了 生成了新的对象
If a result is passed to the combiner or finisher
function, and the same object is not returned from that function, it is
never used again
一旦结果传递给combiner finisher 则不再会传递给accumulator
说明流中元素已经传递完全 accumulator任务已执行完毕
Once a result is passed to the combiner or finisher function, it
is never passed to the accumulator function again
非并发单线程
For non-concurrent collectors, any result returned from the result
supplier, accumulator, or combiner functions must be serially
thread-confined. This enables collection to occur in parallel without
the {@code Collector} needing to implement any additional synchronization.
The reduction implementation must manage that the input is properly
partitioned, that partitions are processed in isolation, and combining
happens only after accumulation is complete
并发多线程
For concurrent collectors, an implementation is free to (but not
required to) implement reduction concurrently. A concurrent reduction
is one where the accumulator function is called concurrently from
multiple threads, using the same concurrently-modifiable result container,
rather than keeping the result isolated during accumulation.
A concurrent reduction should only be applied if the collector has the
{@link Characteristics#UNORDERED} characteristics or if the
originating data is unordered
*/六、Characteristics对Collectors的性能优化
/* Characteristics对Collectors的性能优化
*
* Collectors also have a set of characteristics, that provide hints that can be used by a
* reduction implementation to provide better performance.
*
*
* Characteristics indicating properties of a {@code Collector}, which can
* be used to optimize reduction implementations.
*
* enum Characteristics {
*
* Indicates that this collector is <em>concurrent</em>, meaning that
* the result container can support the accumulator function being
* called concurrently with the same result container from multiple
* threads.
*
* If a {@code CONCURRENT} collector is not also {@code UNORDERED},
* then it should only be evaluated concurrently if applied to an
* unordered data source.
CONCURRENT, 多线程处理并发 一定要保证线程安全 使用无序数据源 与UNORDERED联合使用
* Indicates that the collection operation does not commit to preserving
* the encounter order of input elements. (This might be true if the
* result container has no intrinsic order, such as a {@link Set}.)
UNORDERED, 无序集合
* Indicates that the finisher function is the identity function and
* can be elided. If set, it must be the case that an unchecked cast
* from A to R will succeed.
IDENTITY_FINISH 强制类型转换
}*/
七、Collector接口与 Collectors
// Collectors---> Collector接口简单实现 静态内部类CollectorImpl
// 为什么要在Collectors类内部定义一个静态内部类CollectorImpl：
// Collectors是一个工厂、辅助类 方法的定义是静态的
// 以类名直接调用方法的方式向developer提供最常见的Collector实现 其实现方式是CollectorImpl
// CollectorImpl类 有且仅有在 Collectors类 中使用 所以放在一起八、测试方法
// Accumulate names into a List 将学生姓名累积成ArrayList集合
List<String> snameList = students.stream()
.map(Student::getName).collect(Collectors.toList());
System.out.println("将学生姓名累积成ArrayList集合：" + snameList.getClass());
System.out.println(snameList);
System.out.println("-----------------------------------------\n");
// Accumulate names into a TreeSet 将学生姓名累积成TreeSet集合
Set<String> snameTree = students.stream()
.map(Student::getName).collect(Collectors.toCollection(TreeSet::new));
System.out.println("将学生姓名累积成TreeSet集合：" + snameTree.getClass());
System.out.println(snameTree);
System.out.println("-----------------------------------------\n");
// Convert elements to strings and concatenate them, separated by commas 将学生姓名累积成一个Json串 以逗号分隔
String joinedStudents = students.stream()
.map(Student::toString).collect(Collectors.joining(","));
System.out.println(" 将学生姓名累积成一个Json串 以逗号分隔：" + joinedStudents);
System.out.println("-----------------------------------------\n");
// Compute sum of salaries of students 求学生总薪水
double totalSalary = students.stream()
.mapToDouble(Student::getSalary).sum();
System.out.println("学生总薪水：" + totalSalary);
System.out.println("-----------------------------------------\n");
// the min id of students 打印最小id的学生信息
System.out.println("最小id的学生信息：");
students.stream()
.min(Comparator.comparingInt(Student::getId))
.ifPresent(System.out::println);
System.out.println("-----------------------------------------\n");
// the max id of students 打印最大id的学生信息
System.out.println("最大id的学生信息：");
students.stream()
.max(Comparator.comparingInt(Student::getId))
.ifPresent(System.out::println);
System.out.println("-----------------------------------------\n");
// Compute avg of Age of students 求学生平均年龄
Double avgAge = students.stream()
.collect(Collectors.averagingInt(Student::getAge));
System.out.println("学生平均年龄：" + avgAge);
System.out.println("-----------------------------------------\n");
// Compute SummaryStatistics of Age of students 打印学生年龄的汇总信息
IntSummaryStatistics ageSummaryStatistics = students.stream()
.collect(Collectors.summarizingInt(Student::getAge));
System.out.println("学生年龄的汇总信息：" + ageSummaryStatistics);
System.out.println("-----------------------------------------\n");
// 根据性别分组 取id最小的学生
// 直接使用Collectors.minBy返回的是Optional<Student>
// 因能确认不为Null 使用Collectors.collectingAndThen-->Optional::get获取
Map<String, Student> minIdStudent = students.stream().
collect(Collectors.groupingBy(Student::getSex, Collectors.collectingAndThen
(Collectors.minBy(Comparator.comparingInt(Student::getId)), Optional::get)));
System.out.println(minIdStudent);
System.out.println("-----------------------------------------\n");
}
}九、测试结果
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.1.2.RELEASE)
2019-02-20 16:11:56.217 INFO 17260 --- [ main] c.j.design.java8.Stream.CollectorDetail : Starting CollectorDetail on DESKTOP-87RMBG4 with PID 17260 (started by 46250 in E:\IdeaProjects\design)
2019-02-20 16:11:56.223 INFO 17260 --- [ main] c.j.design.java8.Stream.CollectorDetail : No active profile set, falling back to default profiles: default
2019-02-20 16:11:56.699 INFO 17260 --- [ main] c.j.design.java8.Stream.CollectorDetail : Started CollectorDetail in 0.678 seconds (JVM running for 1.401)
-----------------------------------------
将学生姓名累积成ArrayList集合：class java.util.ArrayList
[Kirito, Asuna, Sinon, Yuuki, Alice]
-----------------------------------------
将学生姓名累积成TreeSet集合：class java.util.TreeSet
[Alice, Asuna, Kirito, Sinon, Yuuki]
-----------------------------------------
将学生姓名累积成一个Json串 以逗号分隔：Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8),Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8),Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8),Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8),Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)
-----------------------------------------
学生总薪水：4.999999995E9
-----------------------------------------
最小id的学生信息：
Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)
-----------------------------------------
最大id的学生信息：
Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)
-----------------------------------------
学生平均年龄：16.0
-----------------------------------------
学生年龄的汇总信息：IntSummaryStatistics{count=5, sum=80, min=14, average=16.000000, max=18}
-----------------------------------------
{Female=Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8), Male=Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)}
-----------------------------------------
标签：combiner,Collectors,Stream,收集器,System,accumulator,result,println,Collector 来源： https://www.cnblogs.com/KingKirito1024/p/10407567.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。