java8新特性（五）：Stream数据收集

收集器Collector

collect方法接受的参数 函数称为 收集器，也就是实现数据收集的策略。

一般来说，收集器collector会对元素应用一个转换函数，并将结果累积在一个数据结构中，从而产生最终输出。

假设一个需求要将交易数据根据货币类型分组

java7 之前需要这么写

List<Transaction> transactions =  new ArrayList<>();
Map<Currency,List<Transaction>>  resultMap =  new HashMap<>();
for(Transaction transaction : transactions){
    Currency currency = transaction.getCurrency();
    List<Transaction> subList = resultMap.get(currency);
    if(subList ==  null){
        subList =  new ArrayList<>();
        resultMap.put(currency, subList);
    }
    subList.add(transaction);
}

在java8 中 只需要这么写

Map<Currency, List<Transaction>> transactionsByCurrencies = transactions.stream().collect(groupingBy(Transaction::getCurrency));

groupingBy就是一个生成收集器的工厂方法

java8中预定义了很多收集器：

求最大值

Comparator<Dish> dishCaloriesComparator = Comparator.comparingInt(Dish::getCalories);

Optional<Dish> mostCalorieDish = menu.stream() .collect(maxBy(dishCaloriesComparator));

求和

int totalCalories = menu.stream().collect(summingInt(Dish::getCalories));

平均值

double avgCalories = menu.stream().collect(averagingInt(Dish::getCalories));

统计全部参数： 总数、最大值、最小值、平均值

IntSummaryStatistics menuStatistics = menu.stream().collect(summarizingInt(Dish::getCalories));

IntSummaryStatistics{count=9, sum=4300, min=120, average=477.777778, max=800}

字符串拼接

String shortMenu = menu.stream().map(Dish::getName).collect(joining(", "));

pork, beef, chicken, french fries, rice, season fruit, pizza, prawns, salmon

求和还可以通过reduce 方法获得

int totalCalories = menu.stream().map(Dish::getCalories).reduce(Integer::sum).get();

int totalCalories = menu.stream().mapToInt(Dish::getCalories).sum();

分组

Map<Dish.Type, List<Dish>> dishesByType = menu.stream().collect(groupingBy(Dish::getType));

{FISH=[prawns, salmon], OTHER=[french fries, rice, season fruit, pizza], MEAT=[pork, beef, chicken]}

多级分组

Map<String, Map<String, List<Dish>>> multiLevelDishes = menu.stream().collect( groupingBy(Dish::getType,  groupingBy(dish -> {
    if(dish.getColories() <=  400)
        return  "DIET";
    else if(dish.getColories() <=  700)
        return  "NORMAL";
    else 
        return  "FAT";

})));

结果是一个两级的Map:

{MEAT={DIET=[chicken], NORMAL=[beef], FAT=[pork]}, FISH={DIET=[prawns], NORMAL=[salmon]},

OTHER={DIET=[rice, seasonal fruit], NORMAL=[french fries, pizza]}}

分组统计

Map<Dish.Type, Long> typesCount = menu.stream().collect( groupingBy(Dish::getType, counting()));

{MEAT=3, FISH=2, OTHER=4}

分组求最大值

Map<Dish.Type, Optional<Dish>> mostCaloricByType = menu.stream()

.collect(groupingBy(Dish::getType, maxBy(comparingInt(Dish::getCalories))));

{FISH=Optional[salmon], OTHER=Optional[pizza], MEAT=Optional[pork]}

分组求和

Map<Dish.Type, Integer> totalCaloriesByType = menu.stream().collect(groupingBy(Dish::getType,

summingInt(Dish::getCalories)));

分区是 分组的一个特殊类型。

Map<Boolean, List<Dish>> partitionMenu = menu.stream().collect(partitioningBy(Dish::isVegetarian));

结果：

{false=[pork, beef, chicken, prawns, salmon], true=[french fries, rice, season fruit, pizza]}

假设一个需求要将质数和非质数分区

要实现这个需求首先知道质数的定义： 质数定义为只能被1或者它本身整除的自然数。

我们写一个方法，它接收一个参数int n, 并且将前n个自然数分为质数和非质数。

首先要写一个测试摸个数是否质数的方法：

//除了1和n本身不能被其他自然数整除，那么n就是一个质数

public boolean isPrime( int n){
    return IntStream. range( 2, n).noneMatch(i -> n % i ==  0);
}

这个方法还可以优化

//如果n不能被2到它的平方根之间的自然数整除，那么n也不能被大于它的平方根在自然数整除。
public boolean isPrime( int n){
    int root = ( int) Math. sqrt(( double) n);
    return IntStream. range( 2, root).noneMatch(i -> n % i ==  0);

}

将质数和非质数分区

public Map<Boolean, List<Integer>> partitionPrimes( int n){
    return IntStream. range( 2, n).boxed().collect( partitioningBy(i -> isPrime(i)));
}

收集器类的静态工厂方法：

工厂方法	返回类型	使用场景	举例
toList	List<T>	Gather all the stream’s items in a List.	List<Dish> dishes = menuStream.collect(toList());
toSet	Set<T>	Gather all the stream’s items in a Set , eliminating duplicates.	Set<Dish> dishes = menuStream.collect(toSet());
toCollection	Collection<T>	Gather all the stream’s items in the collection created by the provided supplier.	Collection<Dish> dishes = menuStream.collect(toCollection(), ArrayList::new);
counting	Long	Count the number of items in the stream.	long howManyDishes = menuStream.collect(counting());
summingInt	Integer	Sum the values of an Integer property of the items in the stream.	int totalCalories = menuStream.collect(summingInt(Dish::getCalories));
averagingInt	Double	Calculate the average value of an Integer property of the items in the stream.	double avgCalories = menuStream.collect(averagingInt(Dish::getCalories));
summarizingInt	IntSummary-Statistics	Collect statistics regarding an Integer property of the items in the stream, such as the maximum, minimum, total, and average.	IntSummaryStatistics menuStatistics = menuStream.collect(summarizingInt(Dish::getCalories));
joining	String	Concatenate the strings resulting from the invocation of the toString method on each item of the stream.	String shortMenu = menuStream.map(Dish::getName).collect(joining(", "));
maxBy	Optional<T>	An Optional wrapping the maximal element in this stream according to the given comparator or Optional.empty() if the stream is empty.	Optional<Dish> fattest = menuStream.collect(maxBy(comparingInt(Dish::getCalories)));
minBy	Optional<T>	An Optional wrapping the minimal element in this stream according to the given comparator or Optional.empty() if the stream is empty.	Optional<Dish> lightest = menuStream.collect(minBy(comparingInt(Dish::getCalories)));
reducing	The type produced by the reduction operation	Reduce the stream to a single value starting from an initial value used as accumulator and iteratively combining it with each item of the stream using a BinaryOperator.	int totalCalories = menuStream.collect(reducing(0, Dish::getCalories, Integer::sum));
collectingAndThen	The type returned by the transforming function	Wrap another collector and apply a transformation function to its result.	int howManyDishes = menuStream.collect(collectingAndThen(toList(), List::size));
groupingBy	Map<K, List<T>>	Group the items in the stream based on the value of one of their properties and use those values as keys in the resulting Map.	Map<Dish.Type,List<Dish>> dishesByType = menuStream.collect(groupingBy(Dish::getType));
partitioningBy	Map<Boolean, List<T>>	Partition the items in the stream based on the result of the application of a predicate to each of them.	Map<Boolean, List<Dish>> vegetarianDishes = menuStream.collect(partitioningBy(Dish::isVegetarian));

 

收集器接口 Collector

collect方法参数类型是Collector接口，

< R,  A>  R collect(Collector<?  super  T,  A,  R> collector);

也就是说所有的收集器都是Collector接口的实现类型。所以我们如果想要开发自己的收集器就需要实现这个接口。

那么就先来看看这个接口有哪些方法。

Supplier< A> supplier();

这个方法返回一个函数，这个函数用来创建并返回一个可变的容器用来存放收集结果。

 

BiConsumer< A,  T> accumulator();

这个函数是累积器 ，它将元素添加到 supplier 接口创建的结果容器

BinaryOperator< A> combiner();

这个方法返回一个函数，这个函数接收两个部分结果集，然后将这两个部分结果集合并成一个结果集。主要在并发计算的时候会用到子集合合并的操作。

Function< A,  R> finisher();

执行最终的转换，将中间计算累积的结果转换成最终的结果

Set<Characteristics> characteristics();

这个方法返回一个枚举类型 Characteristics 的集合，他定义了收集器的行为。

enum Characteristics {

    CONCURRENT,

      accumulator可以被多个线程同时调用，也就是可以并行执行。但是如果数据源是有序的，那么必须同时标注 UNORDERED才可以并行执行。

    UNORDERED,

     归约结果不受流中的元素的遍历和累积顺序影响。

    IDENTITY_FINISH

    这个表明accumulator累积器计算的中间结果类型和最终类型是一致的，finisher完成器中的A和R是相同的类型  ，不需要转换。 

}

开发自己的收集器

实现collector接口，提供对应的实现方法就好了。