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.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.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.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.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.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:
Total elements : 5