Java Collectors

Collectors is a final class that extends Object class. It provides reduction operations, such as accumulating elements into collections, summarizing elements according to various criteria, etc.

Java Collectors class provides various methods to deal with elements

Methods	Description
public static <T> Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T> mapper)	It returns a Collector that produces the arithmetic mean of a double-valued function applied to the input elements. If no elements are present, the result is 0.
public static <T> Collector<T,?,T> reducing(T identity, BinaryOperator<T> op)	It returns a Collector which performs a reduction of its input elements under a specified BinaryOperator using the provided identity.
public static <T> Collector<T,?,Optional<T>> reducing(BinaryOperator<T> op)	It returns a Collector which performs a reduction of its input elements under a specified BinaryOperator. The result is described as an Optional<T>.
public static <T,U> Collector<T,?,U> reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op)	It returns a Collector which performs a reduction of its input elements under a specified mapping function and BinaryOperator. This is a generalization of reducing(Object, BinaryOperator) which allows a transformation of the elements before reduction.
public static <T,K> Collector<T,?,Map<K,List<T>>> groupingBy(Function<? super T,? extends K> classifier)	It 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.
public static <T,K,A,D> Collector<T,?,Map<K,D>> groupingBy(Function<? super T,? extends K> classifier, Collector<? Super T,A,D> downstream)	It 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.
public static <T,K,D,A,M extends Map<K,D>> Collector<T,?,M> groupingBy(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)	It 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. The Map produced by the Collector is created with the supplied factory function.
public static <T,K> Collector<T,?,ConcurrentMap<K,List<T>>> groupingByConcurrent(Function<? super T,? extends K> classifier)	It returns a concurrent Collector implementing a "group by" operation on input elements of type T, grouping elements according to a classification function.
public static <T,K,A,D> Collector<T,?,ConcurrentMap<K,D>> groupingByConcurrent(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)	It 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.
public static <T,K,A,D,M extends ConcurrentMap<K,D>> Collector<T,?,M> groupingByConcurrent(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)	It 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. The ConcurrentMap produced by the Collector is created with the supplied factory function.
public static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningBy(Predicate<? super T> predicate)	It returns a Collector which partitions the input elements according to a Predicate, and organizes them into a Map<Boolean, List<T>>. There are no guarantees on the type, mutability, serializability, or thread-safety of the Map returned.
public static <T,D,A> Collector<T,?,Map<Boolean,D>> partitioningBy(Predicate<? super T> predicate, Collector<? Super T,A,D> downstream)	It 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<Boolean, D> whose values are the result of the downstream reduction.
public static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)	It 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.
public static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)	It 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.
public static <T,K,U,M extends Map<K,U>> Collector<T,?,M> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)	It 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.
public static <T,K,U> Collector<T,?,ConcurrentMap<K,U>> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)	It 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.
public static <T,K,U> Collector<T,?,ConcurrentMap<K,U>> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)	It 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.
public static <T,K,U,M extends ConcurrentMap<K,U>> Collector<T,?,M> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)	It 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.
public static <T> Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)	It returns a Collector which applies an int-producing mapping function to each input element, and returns summary statistics for the resulting values.
public static <T> Collector<T,?,LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)	It returns a Collector which applies an long-producing mapping function to each input element, and returns summary statistics for the resulting values.
public static <T> Collector<T,?,DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)	It returns a Collector which applies an double-producing mapping function to each input element, and returns summary statistics for the resulting values.

Java Collectors Example: Fetching data as a List

import java.util.stream.Collectors;
import java.util.List;
import java.util.ArrayList;
class Product{
	int id;
	String name;
	float price;
	
	public Product(int id, String name, float price) {
		this.id = id;
		this.name = name;
		this.price = price;
	}
}
public class CollectorsExample {
	public static void main(String[] args) {
		List<Product> productsList = new ArrayList<Product>();
		//Adding Products
		productsList.add(new Product(1,"HP Laptop",25000f));
		productsList.add(new Product(2,"Dell Laptop",30000f));
		productsList.add(new Product(3,"Lenevo Laptop",28000f));
		productsList.add(new Product(4,"Sony Laptop",28000f));
		productsList.add(new Product(5,"Apple Laptop",90000f));
		List<Float> productPriceList = 
				productsList.stream()
							.map(x->x.price)			// fetching price
							.collect(Collectors.toList());	// collecting as list
		System.out.println(productPriceList);
	}
}

Output:

[25000.0, 30000.0, 28000.0, 28000.0, 90000.0]

Java Collectors Example: Converting Data as a Set

import java.util.stream.Collectors;
import java.util.Set;
import java.util.List;
import java.util.ArrayList;
classProduct{
	intid;
	String name;
	floatprice;
	
	public Product(intid, String name, floatprice) {
		this.id = id;
		this.name = name;
		this.price = price;
	}
}
publicclass CollectorsExample {
	publicstaticvoid main(String[] args) {
		List<Product>productsList = new ArrayList<Product>();
		//Adding Products
		productsList.add(newProduct(1,"HP Laptop",25000f));
		productsList.add(newProduct(2,"Dell Laptop",30000f));
		productsList.add(newProduct(3,"Lenevo Laptop",28000f));
		productsList.add(newProduct(4,"Sony Laptop",28000f));
		productsList.add(newProduct(5,"Apple Laptop",90000f));
		Set<Float>productPriceList = 
				productsList.stream()
							.map(x->x.price)			// fetching price
							.collect(Collectors.toSet());	// collecting as list
		System.out.println(productPriceList);
	}
}

Output:

[25000.0, 30000.0, 28000.0, 90000.0]

Java Collectors Example: using sum method

import java.util.stream.Collectors;
import java.util.List;
import java.util.ArrayList;
class Product{
	int id;
	String name;
	float price;
	
	public Product(int id, String name, float price) {
		this.id = id;
		this.name = name;
		this.price = price;
	}
}
public class CollectorsExample {
	public static void main(String[] args) {
		List<Product> productsList = new ArrayList<Product>();
		//Adding Products
		productsList.add(new Product(1,"HP Laptop",25000f));
		productsList.add(new Product(2,"Dell Laptop",30000f));
		productsList.add(new Product(3,"Lenevo Laptop",28000f));
		productsList.add(new Product(4,"Sony Laptop",28000f));
		productsList.add(new Product(5,"Apple Laptop",90000f));
		Double sumPrices = 
				productsList.stream()
							.collect(Collectors.summingDouble(x->x.price));	// collecting as list
		System.out.println("Sum of prices: "+sumPrices);
		Integer sumId = 
				productsList.stream().collect(Collectors.summingInt(x->x.id));
		System.out.println("Sum of id's: "+sumId);
	}
}

Output:

Sum of prices: 201000.0
Sum of id's: 15

Java Collectors Example: Getting Product Average Price

import java.util.stream.Collectors;
import java.util.List;
import java.util.ArrayList;
class Product{
	int id;
	String name;
	float price;
	
	public Product(int id, String name, float price) {
		this.id = id;
		this.name = name;
		this.price = price;
	}
}
public class CollectorsExample {
	public static void main(String[] args) {
		List<Product> productsList = new ArrayList<Product>();
		//Adding Products
		productsList.add(new Product(1,"HP Laptop",25000f));
		productsList.add(new Product(2,"Dell Laptop",30000f));
		productsList.add(new Product(3,"Lenevo Laptop",28000f));
		productsList.add(new Product(4,"Sony Laptop",28000f));
		productsList.add(new Product(5,"Apple Laptop",90000f));
		Double average = productsList.stream()
						 .collect(Collectors.averagingDouble(p->p.price));
		System.out.println("Average price is: "+average);
	}
}

Output:

Average price is: 40200.0

Java Collectors Example: Counting Elements

import java.util.stream.Collectors;
import java.util.List;
import java.util.ArrayList;
class Product{
	intid;
	String name;
	floatprice;
	
	public Product(intid, String name, floatprice) {
		this.id = id;
		this.name = name;
		this.price = price;
	}
	publicint getId() {
		returnid;
	}
	public String getName() {
		returnname;
	}
	publicfloat getPrice() {
		returnprice;
	}
}
publicclass CollectorsExample {
	publicstaticvoid main(String[] args) {
		List<Product>productsList = new ArrayList<Product>();
		//Adding Products
		productsList.add(new Product(1,"HP Laptop",25000f));
		productsList.add(new Product(2,"Dell Laptop",30000f));
		productsList.add(new Product(3,"Lenevo Laptop",28000f));
		productsList.add(new Product(4,"Sony Laptop",28000f));
		productsList.add(new Product(5,"Apple Laptop",90000f));
		Long noOfElements = productsList.stream()
							   .collect(Collectors.counting());
		System.out.println("Total elements : "+noOfElements);
	}
}

Output: