A Collector is a mutable reduction operation that accumulates input elements into a mutable result container, optionally transforming the accumulated result into a final representation after all input elements have been processed.

A Collector is a terminal operation which reduces the stream being processed to a Collection. For this reduction it uses a single modifiable collection instance in which it adds all the processed stream elements as it encounters them. Collector also comes with the feature of optionally mapping the stream elements to an equivalent form using specified logic while they are being collected.

What is a mutable reduction operation

A mutable reduction operation(such as Stream.collect())collects the stream elements in a mutable result container(collection) as it processes them. Mutable reduction operations provide much improved performance when compared to an immutable reduction operation(such as Stream.reduce()). This is due to the fact that the collection holding the result at each step of reduction is mutable for a Collector and can be used again in the next step. Stream.reduce() operation, on the other hand, uses immutable result containers and as a result needs to instantiate a new instance of the container at every intermediate step of reduction which degrades performance.

• Step 1 - Supplier provides the mutable empty result container: Supplier is an instance of the SupplierClick to Read Tutorial explaining Supplier functional interface functional interface which provides an instance of a Collection(or Map) to hold the collected elements.
• Step 2 - Accumulator adds individual elements into the result container: Accumulator is an instance of BiConsumer functional interface. It adds individual elements of stream encountered by it into the result container. Accumulation action in this step is known as a fold in functional programming parlance.
• Step 3 - Combiner combines two partial results: Combiner is an instance of a BinaryOperator functional interface which combines two partial results returned by two separate groups of accumulations done in parallel.
• Step 4 - Optional Finisher to put the processed elements in a desired form: Finisher is an instance of a FunctionClick to Read Tutorial explaining Function<T,R> functional interface interface and its use is optional. If required, a Finisher can be used to map the collected elements in the result container to a different required form.
• Step 5 - Final Result: The final collected elements are returned by the Collection in the result container i.e. Collection instance.

• Supplier provides empty instance(or instances for parallel collectors) of type A to begin the accumulation of elements
• Accumulator uses an instance of A to collect T.
• Combiner combines two partial accumulated results of type A to produce a combined instance of A.
• Finisher maps A to R using a mapping function.

//BasicCollector.java
import com.javabrahman.java8.Employee;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class BasicCollector {
  static List<Employee> employeeList = Arrays.asList(new Employee("Tom Jones", 45),
      new Employee("Harry Major", 25),
      new Employee("Ethan Hardy", 65),
      new Employee("Nancy Smith", 22),
      new Employee("Deborah Sprightly", 29));

  public static void main(String args[]){
    Map<Boolean,List<Employee>> employeeMap = 
      employeeList.stream()
                  .collect(Collectors.partitioningBy((Employee emp) -> emp.getAge() > 30));
    System.out.println("Employees partitioned based on age");
    employeeMap.forEach((Boolean key, List<Employee> empList) -> System.out.println(key +"->" + empList));
  }

}

//Employee.java(POJO)
package com.javabrahman.java8;
public class Employee {
  private String name;
  private Integer age;

  public Employee(String name, Integer age) {
    this.name = name;
    this.age = age;
  }

  //Setters & Getters for 'name' and 'age' go here
  
  public String toString(){
    return "Employee Name:"+this.name
        +"  Age:"+this.age;
   }

  @Override
  public boolean equals(Object obj) {
    if (obj == this) {
      return true;
    }
    if (!(obj instanceof Employee)) {
      return false;
    }
    Employee empObj = (Employee) obj;
    return this.age == empObj.age
        && this.name.equalsIgnoreCase(empObj.name);
  }

  @Override
  public int hashCode() {
    int hash = 1;
    hash = hash * 17 + this.name.hashCode();
    hash = hash * 31 + this.age;
    return hash;
  }
}

Employees partitioned based on age
false->[Employee Name:Harry Major  Age:25, Employee Name:Nancy Smith  Age:22, Employee Name:Deborah Sprightly  Age:29]
true->[Employee Name:Tom Jones  Age:45, Employee Name:Ethan Hardy  Age:65]

• Employee is the POJO class for the above example, which contains 2 attributes - name and age.
• In the main() method of BasicCollector class we first create a List of 5 employees, named employeeList, using Arrays.asList()Click to Read Tutorial explaining how Arrays.asList() method works method.
• Next we create a stream of elements of employeeList using employeeList.stream() method.
• We then collect this stream of employee objects using the pipelinedClick to Read tutorial explaining Concept of Pipelines in Computing collect() method to which we pass an instance of Collector returned by Collectors.partitioningBy() method. We partition the employees based on whether their age > 30 or not. Accordingly, we pass a lambda expressionClick to Read Java 8 Lambda Expressions Tutorial for this predicate as input to the partitioningBy() method.
• We then print the entries for employeeMap returned by the collect() method using Map.forEach() method. The output is as expected - a Map containing two entries for keys - true and false, and the values contains lists of Employee objects satisfying/not satisfying the predicate passed.