Java8新特性-011-Stream收集-终止操作

方法	描述
collect(Collector c)	将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到List、Set、Map)。但是Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

方法	返回类型	作用
toList	List	把流中元素收集到List
Listemps=list.stream().collect(Collectors.toList());
toSet	Set	把流中元素收集到Set
Setemps=list.stream().collect(Collectors.toSet());
toCollection	Collection	把流中元素收集到创建的集合
Collectionemps=list.stream().collect(Collectors.toCollection(ArrayList::new));
counting	Long	计算流中元素的个数
longcount=list.stream().collect(Collectors.counting());
summingInt	Integer	对流中元素的整数属性求和
inttotal=list.stream().collect(Collectors.summingInt(Employee::getSalary));
averagingInt	Double	计算流中元素Integer属性的平均值
doubleavg=list.stream().collect(Collectors.averagingInt(Employee::getSalary));
summarizingInt	IntSummaryStatistics	收集流中Integer属性的统计值。如：平均值
IntSummaryStatisticsiss=list.stream().collect(Collectors.summarizingInt(Employee::getSalary));
joining	String	连接流中每个字符串
Stringstr=list.stream().map(Employee::getName).collect(Collectors.joining());
maxBy	Optional	根据比较器选择最大值
Optionalmax=list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary)));
minBy	Optional	根据比较器选择最小值
Optionalmin=list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary)));
reducing	归约产生的类型	从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值
inttotal=list.stream().collect(Collectors.reducing(0,Employee::getSalar,Integer::sum));
collectingAndThen	转换函数返回的类型	包裹另一个收集器，对其结果转换函数
inthow=list.stream().collect(Collectors.co 4000 llectingAndThen(Collectors.toList(),List::size));
groupingBy	Map>	根据某属性值对流分组，属性为K，结果为V
Map

测试代码

TestCollectors.java

package java8.collectors;

import java.util.Arrays;
import java.util.DoubleSummaryStatistics;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import org.junit.Test;

import java8.collectors.Person.Status;

/**
* @author 微信公众号：JavaWeb架构师
* @version 创建时间：2017年12月29日 上午10:32:00
*/
public class TestCollectors {
private List<Integer> listInteger = Arrays.asList(1,2,3,4,80,-1,-2,-3,-4,-5,0,50,10,-60);

private List<Person> listPerson = Arrays.asList(
new Person(Person.Status.VACATION, 18,"冯强"),
new Person(Person.Status.WORK, 16,"周杰伦"),
new Person(Person.Status.REST, 20,"廖周涛"),
new Person(Person.Status.WORK, 25,"鹿晗"),
new Person(Person.Status.VACATION, 25,"吴亦凡")
);
/**
* 1.收集
*     collect(Collector c):
*          将流转换为其他形式。接收一个Collector接口的实现，
*          用于给Stream中元素做汇总的方法
*/

/**
* <R,A> R collect(Collector<? super T,A,R> collector)：
*  使用Collector对此流的元素执行mutable reduction Collector 。
*  A Collector将用作参数的函数封装到collect(Supplier, BiConsumer, BiConsumer) ，允许重用集合策略和组合收集操作（如多级分组或分区）。
*  如果流是并行的，并且Collector是concurrent ，并且流是无序的或收集器是unordered ，
*  则将执行并发的减少（有关并发减少的细节，请参阅Collector ）。
*  这是一个terminal operation 。
*  当并行执行时，可以实例化，填充和合并多个中间结果，以便保持可变数据结构的隔离。
*  因此，即使与非线程安全的数据结构（例如ArrayList ）并行执行，并行还原也不需要额外的同步。
*  参数类型
*      R - 结果的类型
*      A - 中间累积类型的 Collector
*  参数
*      collector - Collector减少的Collector
*  结果
*      减少的结果
*/

/**
* Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到List、Set、Map)。
*  但是Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例。
*/
// 1.把结果转换成List（类似的可以收集到Set、Map）
@Test
public void test1() {

/**
* public static <T> Collector<T,?,List<T>> ：
* toList()返回一个Collector ，它将输入元素List到一个新的List 。
* List返回的类型，可变性，可序列化或线程安全性没有List ;
* 如果需要对返回的List进行更多的控制，请使用toCollection(Supplier) 。
* 参数类型
*  T - 输入元素的类型
* 结果
*  一个 Collector ，它将所有输入元素收集到一个 List中，按照顺序
*/
// 把其中大于0的元素返回到一个List中去
List<Integer> list = listInteger.stream()
.filter((e) -> e > 0)
.collect(Collectors.toList());

// 遍历
list.forEach(System.out::println);
}

// 2.把结果转换成Collection（可以指定到具体的List、Set、Map）
@Test
public void test2() {
// 收集到LinkedList中去
LinkedList<Double> collect = listInteger.stream()
.map((e) -> e + 1.1)
.collect(Collectors.toCollection(LinkedList::new));

collect.forEach(System.out::println);
}

// 3.对结果求平均值、求总和、……
@Test
public void test3() {
// 元素总数
Long count = listInteger.stream().collect(Collectors.counting());
System.out.println("元素总数是：" + count);

// 平均值
Double average = listInteger.stream().collect(Collectors.averagingDouble(Integer::intValue));
System.out.println("平均值是：" + average);

// 求和
Double sum = listInteger.stream().collect(Collectors.summingDouble(Integer::intValue));
System.out.println("总和是：" + sum);

// 最大值
Optional<Integer> maxValue = listInteger.stream().collect(Collectors.maxBy(Integer::compareTo));
System.out.println("最大值是：" + maxValue.get());

// 通过summarizingDouble获取总和、元素个数、平均值、最大最小值
DoubleSummaryStatistics summaryStatistics = listInteger.stream().collect(Collectors.summarizingDouble(Integer::intValue));
System.out.println(summaryStatistics.getCount());
System.out.println(summaryStatistics.getAverage());
System.out.println(summaryStatistics.getSum());
System.out.println(summaryStatistics.getMax());
System.out.println(summaryStatistics.getMin());
}

// 4.分组（单分组、多分组）
@Test
public void test4() {
/**
* 参数(Function)：分组标准Function
*/
// 单按状态分组
Map<Status, List<Person>> statusPersons = listPerson.stream().
collect(Collectors.groupingBy(Person::getStatus));
System.out.println(statusPersons);

/**
* 参数(Function,Collector)：当前分组Function，再分组Collector
*/
// 多分组：先按状态，同状态再按年龄分
Map<Status, Map<String, List<Person>>> mulPerson = listPerson.stream().collect(Collectors.groupingBy(Person::getStatus,
Collectors.groupingBy((e) -> {
if( e.getAge() < 18 ) {
return "少年";
} else if(e.getAge() >= 18 && e.getAge() < 50) {
return "青年";
} else {
return "老年";
}
})));
System.out.println(mulPerson);
}

// 5.分区（true、false两个区域）
@Test
public void test5() {
// 大于等于20岁的一个分区，小于20岁的一个分区
Map<Boolean, List<Person>> partiAge = listPerson.stream().collect(Collectors.partitioningBy((e) -> e.getAge() > 20));
System.out.println(partiAge);
}
}

其它

源码下载

关注下方公众号，回复：Java8.code

欢迎加入交流群：451826376

更多信息：www.itcourse.top