Java 8 Custom Collector with Collector.of() Tutorial

//Employee.java
public class Employee {
  private final String id;
  private final String name;
  private final String department;
  private final double salary;

  public Employee(String id, String name, String department, double salary) {
    this.id = id;
    this.name = name;
    this.department = department;
    this.salary = salary;
  }

  public String getId() { return id; }
  public String getName() { return name; }
  public String getDepartment() { return department; }
  public double getSalary() { return salary; }

  @Override
  public String toString() { return name; }
}

//PayrollStats.java
// A mutable container that a collector fills, one employee at a time
public class PayrollStats {
  private int count;
  private double total;
  private Employee topEarner;

  public void add(Employee e) {
    count++;
    total += e.getSalary();
    if (topEarner == null || e.getSalary() > topEarner.getSalary()) {
      topEarner = e;
    }
  }

  public PayrollStats combine(PayrollStats other) {
    count += other.count;
    total += other.total;
    if (other.topEarner != null
        && (topEarner == null || other.topEarner.getSalary() > topEarner.getSalary())) {
      topEarner = other.topEarner;
    }
    return this;
  }

  public String report() {
    return String.format("%d employees, total %.2f, average %.2f, top earner %s",
        count, total, count == 0 ? 0.0 : total / count, topEarner);
  }
}

//TopN.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;

// A reusable collector that keeps the n greatest elements, in descending order
public class TopN<T> implements Collector<T, PriorityQueue<T>, List<T>> {
  private final int n;
  private final Comparator<? super T> order;

  private TopN(int n, Comparator<? super T> order) {
    this.n = n;
    this.order = order;
  }

  public static <T> TopN<T> of(int n, Comparator<? super T> order) {
    return new TopN<>(n, order);
  }

  @Override
  public Supplier<PriorityQueue<T>> supplier() {
    return () -> new PriorityQueue<>(order);          // smallest of the kept ones at the head
  }

  @Override
  public BiConsumer<PriorityQueue<T>, T> accumulator() {
    return (queue, element) -> {
      queue.add(element);
      if (queue.size() > n) queue.poll();             // drop the smallest
    };
  }

  @Override
  public BinaryOperator<PriorityQueue<T>> combiner() {
    return (left, right) -> {
      for (T element : right) {
        left.add(element);
        if (left.size() > n) left.poll();
      }
      return left;
    };
  }

  @Override
  public Function<PriorityQueue<T>, List<T>> finisher() {
    return queue -> {
      List<T> result = new ArrayList<>(queue);
      result.sort(Collections.reverseOrder(order));
      return result;
    };
  }

  @Override
  public Set<Characteristics> characteristics() {
    return EnumSet.of(Characteristics.UNORDERED);
  }
}

//CustomCollectors.java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collector;

public class CustomCollectors {

  public static void main(String[] args) {
    List<Employee> staff = Arrays.asList(
        new Employee("E-1001", "Tom Jones", "Finance", 5200),
        new Employee("E-1002", "Harry Major", "Finance", 4100),
        new Employee("E-1003", "Ethan Hardy", "Sales", 6300),
        new Employee("E-1004", "Nancy Smith", "Sales", 5800),
        new Employee("E-1005", "Deborah Sprightly", "IT", 7000));

    // 1. Collector.of() with a supplier, accumulator, combiner and finisher
    Collector<Employee, PayrollStats, String> payrollReport = Collector.of(
        PayrollStats::new,          // supplier: a new, empty container
        PayrollStats::add,          // accumulator: add one element to a container
        PayrollStats::combine,      // combiner: merge two partial containers
        PayrollStats::report);      // finisher: turn the container into the result
    System.out.println("1. sequential: " + staff.stream().collect(payrollReport));
    System.out.println("   parallel:   " + staff.parallelStream().collect(payrollReport));

    // 2. Without a finisher the container itself is the result (IDENTITY_FINISH)
    Collector<String, StringBuilder, StringBuilder> initials = Collector.of(
        StringBuilder::new,
        (sb, name) -> sb.append(name.charAt(0)),
        StringBuilder::append);
    StringBuilder result = Arrays.asList("Tom", "Harry", "Ethan", "Nancy").stream()
        .collect(initials);
    System.out.println("2. initials: " + result + ", characteristics: "
        + initials.characteristics());

    // 3. A reusable collector class implementing the Collector interface
    List<Employee> topThree = staff.stream()
        .collect(TopN.of(3, Comparator.comparingDouble(Employee::getSalary)));
    System.out.println("3. top 3 by salary: " + topThree);

    // 4. The same collector on another type
    List<Integer> topTwo = Arrays.asList(42, 7, 99, 15, 63).parallelStream()
        .collect(TopN.of(2, Comparator.<Integer>naturalOrder()));
    System.out.println("4. top 2 numbers: " + topTwo);

    // 5. A collector into an ArrayList, the way Collectors.toList() works
    Collector<String, ?, List<String>> toArrayList = Collector.of(
        ArrayList::new, List::add, (a, b) -> { a.addAll(b); return a; });
    System.out.println("5. " + Arrays.asList("Tom", "Harry").stream().collect(toArrayList));
  }
}