¿Cómo funciona el método Java filter() en segundo plano?

 El método filter() se utiliza en la programación funcional como un método intermedio. Un predicado es un predicado sin estado que no interfiere y que se aplica a cada elemento para determinar si debe incluirse.

Sintaxis: método filter() 

filter(Predicate predicate)

Parámetro: un predicado

Tipo de valor devuelto: una secuencia que consta de los elementos de la secuencia aprobada que coinciden con el predicado dado.

¿Alguna vez se ha preguntado qué sucede cuando escribimos el siguiente ejemplo que es una expresión lambda con un elemento asignado a un ‘ element%2==0 ‘ ? Entonces, ¿qué está sucediendo realmente detrás de las pantallas? ¿Cómo funciona realmente? Toda la magia de esto se basa en algo que se llama interfaz funcional , ya que la interfaz funcional tiene exactamente un método abstracto. Dado que los métodos predeterminados tienen una implementación, no son abstractos. Por ejemplo, Predicate Interface, Consumer Interface son interfaces funcionales.

List.of(10,5,23,54).stream().filter(element -> element%2==0);

Implementación: Considere el siguiente programa que usa el método filter() para eliminar los números impares y devuelve el flujo de números que son divisibles por 2, es decir, números pares.

Ejemplo 1:

// Java Program to demonstrate Use of filter() Method
 
// Importing all. input output classes
import java.io.*;
// Importing List class from java.util package
import java.util.List;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // 1. Creating List of integers later on
        // 2. converting List to a Stream in which
        // 3. logic is to eliminate the odd numbers and
        // finally
        // 4. Printing each element of stream returned by
        // filter() method
        List.of(12, 34, 67, 19, 32, 4)
            .stream()
            .filter(element -> element % 2 == 0)
            .forEach(
                element -> System.out.println(element));
    }
}

12
34
32
4

Flujo de trabajo interno:

• Cuando el flujo de [12, 34, 67, 19, 32, 4] se pasa al método de filtro, prueba cada elemento usando el predicado proporcionado (elemento → elemento% 2 == 0) y devuelve el flujo de números pares [ 12, 34, 32, 4].
• Ahora, ¿qué está pasando detrás de las pantallas? ¿Cómo se envía el fragmento de código ‘ elemento → elemento%2 == 0 ‘ al método de filtro?
• Si observamos la firma del método filter() es como sigue, donde se puede ver que está tomando un Predicado en el argumento.

public abstract Stream<T> filter(Predicate<? super T> predicate)

• Entonces, cuando vamos a la documentación de Predicate, tiene la siguiente firma de la siguiente manera con la anotación @FunctionalInterface escrita arriba

public interface Predicate<T>

• El método funcional que está presente en esta interfaz Predicate es el siguiente:

boolean Test(T t) ;

• Devuelve un predicado compuesto que representa un AND lógico de este predicado y otro. Al evaluar el predicado compuesto, si este predicado es falso, entonces el otro predicado no se evalúa.
• En la interfaz de predicado, Test() es el único método que no tiene escrita ninguna implementación predeterminada. Ahora, ¿cómo se asigna ‘ elemento -> elemento%2 == 0 ‘ a la implementación de la interfaz Predicate?
• Tenemos un método test() que acepta un predicado de interfaz como argumento, luego solo podemos pasar los objetos de las implementaciones de esa interfaz como parámetros a ese método.

Ejemplo 2:

// Java Program to Implementation of the Predicate interface
 
// Importing input output classes
import java.io.*;
// Importing classes from java.util package
import java.util.List;
import java.util.function.Predicate;
 
// Class 1
// helper class
// Implementation of Predicate interface
class EvenNumberPredicate implements Predicate<Integer> {
 
    // Implementing all unimplemented method of the
    // Predicate interface.
    // @Override
    public boolean test(Integer number)
    {
 
        // Returns true for Even and false for Odd
        return number % 2 == 0;
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // 1. Creating List of integers then
        // 2. Converting list to stream further
        // 3. Passing the object of Predicate to the filter
        // method
        List.of(12, 34, 67, 19, 32, 4)
            .stream()
            .filter(new EvenNumberPredicate())
            .forEach(
                element -> System.out.println(element));
    }
}

12
34
32
4

Nota: Ambos programas producen el mismo resultado.

Cuando pasamos el objeto de EvenNumberPredicate() al método de filtro como un argumento, lo que hace es para cada elemento de la secuencia que se le pasa, verificará la condición proporcionada en el método anulado test() de EvenNumberPredicate() y incluye el elemento en el flujo de retorno si test() devuelve verdadero; de lo contrario, se niega a incluir el elemento en el flujo de retorno si el método test() devuelve falso. Por ejemplo: para el elemento 12, test()El método devuelve verdadero, por lo que se incluye en el flujo de retorno, mientras que para el elemento 67 test() devuelve falso, por lo que 67 no se incluye en el flujo de retorno. El ejemplo 2 muestra exactamente lo que sucede cuando pasamos algo de lógica al método filter(). Esto significa que, cuando pasamos algo de lógica al método filter(), el compilador de Java en segundo plano crea una implementación de la interfaz funcional.

Nota: La característica más importante de una interfaz funcional como Predicate es que tendría solo un método que no tendrá una definición y, básicamente, lo que hacemos cuando creamos una expresión Lambda es proporcionar implementación (o lógica). código) para ese método específico.

En este caso (es decir, filter()) le estamos diciendo al compilador que toma el único método que no está implementado test() en el caso de Predicate y proporciona la lógica escrita en el método de filtro como implementación.