Collectors

Collectors它是个工具类，提供了很多静态方法来返回Collector。通常作为Stream.collect()方法的入参，来实现更多的功能。

API分类

求平均值

static  Collector	averagingDouble(ToDoubleFunction mapper) Returns a Collector that produces the arithmetic mean of a double-valued function applied to the input elements.
static  Collector	averagingInt(ToIntFunction mapper) Returns a Collector that produces the arithmetic mean of an integer-valued function applied to the input elements.
static  Collector	averagingLong(ToLongFunction mapper) Returns a Collector that produces the arithmetic mean of a long-valued function applied to the input elements.

 统计

static  Collector

counting() Returns a Collector accepting elements of type T that counts the number of input elements.

 分组

static  Collector>>	groupingBy(Function classifier) Returns a Collector implementing a "group by" operation on input elements of type T, grouping elements according to a classification function, and returning the results in a Map.
static  Collector>	groupingBy(Function classifier, Collector downstream) Returns a Collector implementing a cascaded "group by" operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector.
static > Collector	groupingBy(Function classifier, Supplier mapFactory, Collector downstream) Returns a Collector implementing a cascaded "group by" operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector.
static  Collector>>	groupingByConcurrent(Function classifier) Returns a concurrent Collector implementing a "group by" operation on input elements of type T, grouping elements according to a classification function.
static  Collector>	groupingByConcurrent(Function classifier, Collector downstream) Returns a concurrent Collector implementing a cascaded "group by" operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector.
static > Collector	groupingByConcurrent(Function classifier, Supplier mapFactory, Collector downstream) Returns a concurrent Collector implementing a cascaded "group by" operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector.

 

 字符串操作

static Collector	joining() Returns a Collector that concatenates the input elements into a String, in encounter order.
static Collector	joining(CharSequence delimiter) Returns a Collector that concatenates the input elements, separated by the specified delimiter, in encounter order.
static Collector	joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix) Returns a Collector that concatenates the input elements, separated by the specified delimiter, with the specified prefix and suffix, in encounter order.

 

 mapping

类似Stream.map()方法

static  Collector

mapping(Function mapper, Collector downstream) Adapts a Collector accepting elements of type U to one accepting elements of type T by applying a mapping function to each input element before accumulation.

最值

static  Collector>	maxBy(Comparator comparator) Returns a Collector that produces the maximal element according to a given Comparator, described as an Optional.
static  Collector>	minBy(Comparator comparator) Returns a Collector that produces the minimal element according to a given Comparator, described as an Optional.

 

 分区

返回一个Map，key值为true或false，value为满足对应条件的数据。

static  Collector>>	partitioningBy(Predicate predicate) Returns a Collector which partitions the input elements according to a Predicate, and organizes them into a Map>.
static  Collector>	partitioningBy(Predicate predicate, Collector downstream) Returns a Collector which partitions the input elements according to a Predicate, reduces the values in each partition according to another Collector, and organizes them into a Map whose values are the result of the downstream reduction.

 

 规约

static  Collector>	reducing(BinaryOperator op) Returns a Collector which performs a reduction of its input elements under a specified BinaryOperator.
static  Collector	reducing(T identity, BinaryOperator op) Returns a Collector which performs a reduction of its input elements under a specified BinaryOperator using the provided identity.
static  Collector	reducing(U identity, Function mapper, BinaryOperator op) Returns a Collector which performs a reduction of its input elements under a specified mapping function and BinaryOperator.

 

求和

static  Collector	summingDouble(ToDoubleFunction mapper) Returns a Collector that produces the sum of a double-valued function applied to the input elements.
static  Collector	summingInt(ToIntFunction mapper) Returns a Collector that produces the sum of a integer-valued function applied to the input elements.
static  Collector	summingLong(ToLongFunction mapper) Returns a Collector that produces the sum of a long-valued function applied to the input elements.

 

 summarizing

返回各种SummarayStatistics对象，通过这些对象可以获取最大值、最小值、平均值、计数等。

static  Collector	summarizingDouble(ToDoubleFunction mapper) Returns a Collector which applies an double-producing mapping function to each input element, and returns summary statistics for the resulting values.
static  Collector	summarizingInt(ToIntFunction mapper) Returns a Collector which applies an int-producing mapping function to each input element, and returns summary statistics for the resulting values.
static  Collector	summarizingLong(ToLongFunction mapper) Returns a Collector which applies an long-producing mapping function to each input element, and returns summary statistics for the resulting values.

 

集合转换

可以将Stream流转换成List、Map、Set集合。

static > Collector	toCollection(Supplier collectionFactory) Returns a Collector that accumulates the input elements into a new Collection, in encounter order.
static  Collector>	toConcurrentMap(Function keyMapper, Function valueMapper) Returns a concurrent Collector that accumulates elements into a ConcurrentMap whose keys and values are the result of applying the provided mapping functions to the input elements.
static  Collector>	toConcurrentMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction) Returns a concurrent Collector that accumulates elements into a ConcurrentMap whose keys and values are the result of applying the provided mapping functions to the input elements.
static > Collector	toConcurrentMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction, Supplier mapSupplier) Returns a concurrent Collector that accumulates elements into a ConcurrentMap whose keys and values are the result of applying the provided mapping functions to the input elements.
static  Collector>	toList() Returns a Collector that accumulates the input elements into a new List.
static  Collector>	toMap(Function keyMapper, Function valueMapper) Returns a Collector that accumulates elements into a Map whose keys and values are the result of applying the provided mapping functions to the input elements.
static  Collector>	toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction) Returns a Collector that accumulates elements into a Map whose keys and values are the result of applying the provided mapping functions to the input elements.
static > Collector	toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction, Supplier mapSupplier) Returns a Collector that accumulates elements into a Map whose keys and values are the result of applying the provided mapping functions to the input elements.
static  Collector>	toSet() Returns a Collector that accumulates the input elements into a new Set.

案例 

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class CollectorsTest2 {
	public static void main(String[] args) {
		List list = new ArrayList<>();
		list.add(new Book("Core Java", 200,30));
		list.add(new Book("Learning Freemarker", 150, 50));
		list.add(new Book("Spring MVC", 300, 50));
//		list.add(new Book("Spring MVC", 300, 50));

		// averagingDouble方法
		ToDoubleFunction toDoubleFunction = new ToDoubleFunction() {
			@Override
			public double applyAsDouble(Book book) {
				return book.getPrice();
			}
		};

		Double averagingDouble = list.stream().collect(Collectors.averagingDouble(toDoubleFunction));
		System.out.println(averagingDouble);


		// averagingInt
		Double averagingInt = list.stream().collect(Collectors.averagingInt(Book::getCount));
		System.out.println(averagingInt);

		// averagingLong
		Double averagingLong = list.stream().collect(Collectors.averagingLong(Book::getCount));
		System.out.println(averagingLong);

		// collectingAndThen
		Integer andThen = list.stream().collect(Collectors.collectingAndThen(Collectors.groupingBy(Book::getName), map -> map.size()));
		System.out.println(andThen);

 		// `counting()`
		Long count = list.stream().collect(Collectors.counting());
		System.out.println(count);

		// groupingBy
		Map> groupingBy = list.stream().collect(Collectors.groupingBy(Book::getName));
		System.out.println(groupingBy); // {Learning Freemarker=[Book{name='Learning Freemarker', price=150.0, count=50}], Core Java=[Book{name='Core Java', price=200.0, count=30}], Spring MVC=[Book{name='Spring MVC', price=300.0, count=50}, Book{name='Spring MVC', price=300.0, count=50}]}

		Map groupingBy_Reduce = list.stream().collect(Collectors.groupingBy(Book::getName, Collectors.counting()));
		System.out.println(groupingBy_Reduce); // {Learning Freemarker=1, Core Java=1, Spring MVC=2}

		HashMap groupingBy_ResultMap_Reduce = list.stream().collect(Collectors.groupingBy(Book::getName, HashMap::new, Collectors.counting()));
		System.out.println(groupingBy_ResultMap_Reduce); // {Learning Freemarker=1, Core Java=1, Spring MVC=2}

		// groupingByConcurrent
		ConcurrentMap> concurrentGroupBy = list.stream().collect(Collectors.groupingByConcurrent(Book::getName));
		ConcurrentMap concurrentGroupBy_Reduce = list.stream().collect(Collectors.groupingByConcurrent(Book::getName, Collectors.counting()));
		ConcurrentHashMap concurrentGroupBy_ResultMap_Reduce = list.stream().collect(Collectors.groupingByConcurrent(Book::getName, ConcurrentHashMap::new, Collectors.counting()));

		// joining
		String joining = list.stream().map(Book::getName).collect(Collectors.joining(","));
		System.out.println(joining); // Core Java,Learning Freemarker,Spring MVC,Spring MVC

		// mapping
		String mapping = list.stream().collect(Collectors.mapping(Book::getName, Collectors.joining(",")));
		System.out.println(mapping); // Core Java,Learning Freemarker,Spring MVC,Spring MVC

		// maxBy
		Optional maxBy = list.stream().collect(Collectors.maxBy(Comparator.comparing(Book::getPrice)));
		maxBy.ifPresent(System.out::println); // Book{name='Spring MVC', price=300.0, count=50}

		// minBy
		Optional minBy = list.stream().map(Book::getName).collect(Collectors.maxBy(String::compareTo));
		minBy.ifPresent(System.out::println); // Spring MVC

		// partitioningBy
		Map> partitioningBy = list.stream().collect(Collectors.partitioningBy(book -> book.getPrice() > 200));
		System.out.println(partitioningBy); // {false=[Book{name='Core Java', price=200.0, count=30}, Book{name='Learning Freemarker', price=150.0, count=50}], true=[Book{name='Spring MVC', price=300.0, count=50}, Book{name='Spring MVC', price=300.0, count=50}]}

		Map partitioningBy_Reduce = list.stream().collect(Collectors.partitioningBy(book -> book.getPrice() > 200, Collectors.counting()));
		System.out.println(partitioningBy_Reduce); // {false=2, true=2}

		// reducing
		Optional reducing = list.stream().collect(Collectors.reducing(BinaryOperator.maxBy(Comparator.comparing(Book::getPrice))));
		reducing.ifPresent(System.out::println); // Book{name='Spring MVC', price=300.0, count=50}

		// summarizing
		IntSummaryStatistics intSummaryStatistics = list.stream().collect(Collectors.summarizingInt(Book::getCount));
		double average = intSummaryStatistics.getAverage();
		long count1 = intSummaryStatistics.getCount();
		int max = intSummaryStatistics.getMax();
		int min = intSummaryStatistics.getMin();

		// toConcurrentMap
		ConcurrentMap toConcurrentMap = list.stream().collect(Collectors.toConcurrentMap(Book::getName, Book::getCount));
		System.out.println(toConcurrentMap);

		// toList
		List toList = list.stream().collect(Collectors.toList());

		// toMap
		Map toMap = list.stream().collect(Collectors.toMap(Book::getName, Book::getCount));
	}

	static class Book {
		private String name;
		private double price;
		private int count;

		public Book(String name, double price, int count) {
			this.name = name;
			this.price = price;
			this.count = count;
		}

		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}

		public double getPrice() {
			return price;
		}

		public void setPrice(double price) {
			this.price = price;
		}

		public int getCount() {
			return count;
		}

		public void setCount(int count) {
			this.count = count;
		}

		@Override
		public String toString() {
			return "Book{" +
					"name='" + name + '\'' +
					", price=" + price +
					", count=" + count +
					'}';
		}
	}
}

希望能帮助大家熟悉Collectors的使用。