¿Cómo construir un recopilador personalizado en Java?

Java Collector es la clase de utilidad que proporciona muchos métodos y funciones útiles para la interfaz del recopilador. Principalmente, la implementación del colector se usa con el método stream collect(). La interfaz del recopilador fue proporcionada por Java 8 bajo la parte de la API Java Stream recientemente introducida. Esta interfaz proporciona varios métodos para realizar operaciones de reducción mutua. Las operaciones de reducción mutable realizan funciones aritméticas en la información matemática en una secuencia para encontrar elementos mínimos, máximos, promedio o acumulativos de una secuencia en un conjunto o concatenar todos los elementos de string de la secuencia.

Pasos para crear un recopilador personalizado

Para escribir recopiladores personalizados, se supone que debemos implementar la interfaz con los métodos mencionados a continuación. La recopilación generalmente ocurre en cuatro pasos proporcionados por Streams API.

• Proveedor(): este es el primer paso del proceso de recopilación de elementos y, en este proceso, se crea el contenedor para contener los elementos de la secuencia. El tipo de devolución de este método es el proveedor del tipo de contenedor.
• Acumulador(): este es el segundo paso en el que cada elemento se agrega al contenedor creado por el paso del proveedor. En este método, tenemos que devolver una función BiConsumer que acepte el contenedor y todos los elementos del Stream.
• Combiner() : este es el paso opcional, que se ejecuta solo cuando la secuencia se procesa en una era paralela, y si la secuencia es secuencial, este paso se omitirá. El paso Combinar se utiliza para combinar todos los elementos en un solo contenedor. En este método, se supone que debemos devolver una función de operador binario que combina dos contenedores acumulados.
• Finish(): Es el último paso en el proceso de recolección. Se ejecutará solo cuando todos los elementos de la secuencia se acumulen correctamente en el contenedor del proveedor. En este método, podemos devolver una función para transformar el contenedor acumulado y combinado en el resultado final.

Además de estos métodos , tenemos el método de características() para especificar las características del Recopilador y los valores Enum de tipo de retorno de un conjunto de características.

Ejemplo

Para ilustrar este ejemplo, dividiremos el código en tres secciones para una mejor comprensión. Tomemos un ejemplo en el que tenemos una lista de objetos Employee y queremos crear una secuencia a partir de ella y recopilar los objetos Employee como una lista inmutable de Trillizos. Cada uno de los trillizos de la lista representará a un empleado y tendrá la edad, el nombre y el apellido del empleado.

public class Employee_GFG {
    private long id;
    private String firstName;
    private String lastName;
    private int year;
  
    public Employee_GFG(long id, String firstName,
                        String lastName, int year)
    {
        this.id = id;
        this.firstName = firstName;
        this.lastName = lastName;
        this.year = year;
    }
  
    public long getId() { return id; }
  
    public void setId(long id) { this.id = id; }
  
    public String getFirstName() { return firstName; }
  
    public void setFirstName(String firstName)
    {
        this.firstName = firstName;
    }
  
    public String getLastName() { return lastName; }
  
    public void setLastName(String lastName)
    {
        this.lastName = lastName;
    }
  
    public int getYear() { return year; }
  
    public void setYear(int year) { this.year = year; }
}

En el ejemplo mencionado anteriormente, tenemos una clase llamada Employee_GFG que consiste en una variable privada llamada id, nombre, apellido, año, Constructor, que inicializa las variables y también tiene varias funciones setFirstName, getLastName, set LastName, getYear, setYear, etc. esta función simplemente establezca u obtenga los valores de la variable.

Ahora tenemos que implementar la interfaz de Collector. Para crear la clase para los métodos de recopilación para el proveedor, el acumulador y el finalizador, como se explicó anteriormente.

package com.example.geeksforgeeks.customcollector;
  
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
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;
import org.javatuples.Triplet;
  
public class EmployeeCollector implements
  
    Collector<Employee,
              List<Triplet<Integer, String, String> >,
              List<Triplet<Integer, String, String> > > {
  
    public static EmployeeCollector toEmployeeList()
    {
        return new EmployeeCollector();
    }
  
    public Supplier<
        List<Triplet<Integer, String, String> > >
    supplier()
    {
        return ArrayList::new;
    }
  
    public BiConsumer<
        List<Triplet<Integer, String, String> >, Student>
    accumulator()
    {
        return (list, student)
                   -> list.add(
                       Triplet.with(student.getYear(),
                                    student.getFirstName(),
                                    student.getLastName()));
    }
  
    public BinaryOperator<
        List<Triplet<Integer, String, String> > >
    combiner()
    {
        return (list1, list2) ->
        {
            list1.addAll(list2);
            return list1;
        };
    }
  
    @Override
    public Function<
        List<Triplet<Integer, String, String> >,
        List<Triplet<Integer, String, String> > >
    finisher()
    {
        return Collections::unmodifiableList;
    }
  
    @Override public Set<Characteristics> characteristics()
    {
        return Set.of(Characteristics.UNORDERED);
    }
}

En el ejemplo mencionado anteriormente, creamos una clase llamada EmployeeCollector. Debajo de eso, implementamos un recopilador personalizado con triplete Entero, Entero, String y función de proveedor escrita que proporciona un contenedor para contener elementos Stream y proporciona una nueva ArrayList cuando se invoca. La función BiConsumer en esta función de retorno obtiene el contenedor, que es un ArrayList y un objeto Student de la secuencia, la función BinaryOperator es un combinador que toma los contenedores como argumentos y devuelve un nombre de función de último segundo «Función» el contenedor que es un ArrayList de trillizos de estudiantes y devuelve una Lista no modificable.

Ahora, usaremos nuestro recopilador en flujos de empleados. Usaremos la función toEmployeeList() en el método collect().

public static void main(String[] args)
{
    List<Employee> Employee = List.of(
        new Employee(1, "samarth", "sharma", 2019),
        new Employee(2, "praful", "john", 2019),
        new Employee(3, "goutam", "verma", 2015),
        new Employee(4, "mohit", "verma", 2016));
  
    List<Triplet<Integer, String, String> > listOfTriples
        = Employee.stream().collect(
            EmployeeCollector.toEmployeeList());
    listOfTriples.forEach(System.out::println);
}

Producción

[1,samarth,sharma,2019]
[2,praful,john,2019]
[3,goutam,verma,2015]
[4,mohit,verma,2016]

Arriba está el resultado deseado del código, que consiste en una lista de un empleado con nombre, apellido, año e identificación.