Recopiladores partitioningBy() método en Java

El método PartitioningBy() de Collectors es un método predefinido de la clase java.util.stream.Collectors que se utiliza para particionar un flujo de objetos (o un conjunto de elementos) en función de un predicado determinado. Hay dos variantes sobrecargadas del método que están presentes. Uno toma solo un predicado como parámetro, mientras que el otro toma tanto el predicado como una instancia de recopilador como parámetros.

particiónPor(Predicado<? super T> predicado)

Sintaxis:

public static <T> Collector<T, ?, Map<Boolean, List<T>>> particionadoBy(Predicate<? super T> predicate)

dónde,

• Interface Collector< T, A, R > : una operación de reducción mutable que acumula elementos de entrada en un contenedor de resultados mutable, transformando opcionalmente el resultado acumulado en una representación final después de que se hayan procesado todos los elementos de entrada. Las operaciones de reducción se pueden realizar secuencialmente o en paralelo.
  • T: El tipo de elementos de entrada a la operación de reducción.
  • A: El tipo de acumulación mutable de la operación de reducción.
  • R: El tipo de resultado de la operación de reducción.
• Map<Boolean, List<T>>: el mapa que contiene la salida. Las claves son valores booleanos (verdadero o falso) y los valores correspondientes son listas que contienen elementos de tipo T.

Parámetros: este método toma un predicado de parámetro obligatorio que es una instancia de una interfaz de predicado de tipo T .

Valor de retorno: este método devuelve un recopilador que implementa la operación de partición.

A continuación se muestra un ejemplo para ilustrar el método de partición por():

Programa:

// Java code to show the implementation of
// Collectors partitioningBy() function
  
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
  
class Gfg {
  
    // Driver code
    public static void main(String[] args)
    {
        // creating an Integer stream
        Stream<Integer>
            s = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  
        // using Collectors partitioningBy()
        // method to split the stream of elements into
        // 2 parts, greater than 3 and less than 3.
        Map<Boolean, List<Integer> >
            map = s.collect(
                Collectors.partitioningBy(num -> num > 3));
  
        // Displaying the result as a map
        // true if greater than 3, false otherwise
        System.out.println("Elements in stream "
                           + "partitioned by "
                           + "less than equal to 3: \n"
                           + map);
    }
}

Elements in stream partitioned by less than equal to 3: 
{false=[1, 2, 3], true=[4, 5, 6, 7, 8, 9, 10]}

partición por (predicado <? super T> predicado, colector <? super T, A, D> aguas abajo)

Sintaxis:

public static <T> Collector<T, ?, Map<Boolean, List<T>>> particionadoBy(Predicate<? super T>predicate, Collector<? super T, A, D> downstream)

dónde,

• Interface Collector< T, A, R > : una operación de reducción mutable que acumula elementos de entrada en un contenedor de resultados mutable, transformando opcionalmente el resultado acumulado en una representación final después de que se hayan procesado todos los elementos de entrada. Las operaciones de reducción se pueden realizar secuencialmente o en paralelo.
  • T: El tipo de elementos de entrada a la operación de reducción.
  • A: El tipo de acumulación mutable de la operación de reducción.
  • R: El tipo de resultado de la operación de reducción.
• Map<Boolean, List<T>>: el mapa que contiene la salida. Las claves son valores booleanos (verdadero o falso) y los valores correspondientes son listas que contienen elementos de tipo T.

Parámetros: este método toma dos parámetros, un predicado que es una instancia de una interfaz de predicado de tipo T y un recopilador que se utiliza para implementar la «reducción descendente» y producir la salida.

Valor de retorno: este método devuelve un recopilador que implementa la operación de partición.

A continuación se muestra un ejemplo para ilustrar el tipo 2 del método de partición por():

// Java code to show the implementation of
// Collectors partitioningBy() function
  
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
  
class ArraytoArrayList {
  
    // Driver code
    public static void main(String[] args)
    {
        // creating an Integer stream
        Stream<Integer>
            s = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  
        // Using Collectors.counting() method
        // to count the number of elements in
        // the 2 partitions
        Map<Boolean, Long>
            map = s.collect(
                Collectors.partitioningBy(
                    num -> (num > 3), Collectors.counting()));
  
        // Displaying the result as a map
        // true if greater than 3, false otherwise
        System.out.println("Elements in stream "
                           + "partitioned by "
                           + "less than equal to 3: \n"
                           + map);
    }
}

Elements in stream partitioned by less than equal to 3: 
{false=3, true=7}