Bloquear expresiones Lambda en Java

La expresión lambda es un método sin nombre que no se ejecuta por sí solo. Estas expresiones causan una clase anónima. Estas expresiones lambda se denominan cierres. El cuerpo de Lambda consiste en un bloque de código. Si tiene una sola expresión se denominan “ Cuerpos de Expresión ”. Las lambdas que contienen cuerpos de expresión se conocen como » Lambdas de expresión «. A continuación se muestra un ejemplo de la expresión Lambda en una sola línea.

Block Lambda contiene muchas operaciones que funcionan en expresiones lambda, ya que permite que el cuerpo lambda tenga muchas declaraciones. Esto incluye variables, bucles, declaraciones condicionales como declaraciones if, else y switch, bloques anidados, etc. Esto se crea encerrando el bloque de declaraciones en el cuerpo lambda entre llaves {}. Esto puede incluso tener una declaración de retorno, es decir, valor de retorno.

Sintaxis: expresiones lambda

(parameters) -> { lambda body }

Ahora, primero entendamos la expresión Lambda para conocer la expresión lambda de bloque.

Ilustración: 

En este caso, lambda puede necesitar más de una sola expresión en su cuerpo lambda. Java admite Expression Lambdas, que contiene bloques de código con más de una instrucción. Llamamos a este tipo de Cuerpo Lambda un “ Cuerpo de Bloque ”. Las lambdas que contienen cuerpos de bloque se pueden conocer como «Lambdas de bloque « .

 Ejemplo Representando la expresión Lambda

// Java Program to illustrate Lambda expression
 
// Importing input output classes
import java.io.*;
 
// Interface
// If1 is name of this interface
interface If1 {
 
    // Member function of this interface
    // Abstract function
    boolean fun(int n);
}
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Lambda expression body
        If1 isEven = (n) -> (n % 2) == 0;
 
        // Above is lambda expression which tests
        // passed number is even or odd
 
        // Condition check over some number N
        // by calling the above function
        // using isEven() over fun() defined above
 
        // Input is passed as a parameter N
        // Say custom input N = 21
        if (isEven.fun(21))
 
            // Display message to be printed
            System.out.println("21 is even");
        else
 
            // Display message to be printed
            System.out.println("21 is odd");
    }
}

21 is odd

Ahora cambiemos a la implementación de la expresión lambda de bloque seguida de dos ejemplos como se muestra a continuación:

Implementación: 

Ejemplo 1:

// Java Program to illustrate Block Lambda expression
 
// Importing all classes from
// java.util package
import java.io.*;
 
// Block lambda to find out factorial
// of a number
 
// Interface
interface Func {
    // n is some natural number whose
    // factorial is to be computed
    int fact(int n);
}
 
// Class
// Main class
class GFG {
    // Main driver method
    public static void main(String[] args)
    {
        // Block lambda expression
        Func f = (n) ->
        {
            // Block body
 
            // Initially initializing with 1
            int res = 1;
 
            // iterating from 1 to the current number
            // to find factorial by multiplication
            for (int i = 1; i <= n; i++)
                res = i * res;
            return res;
        };
 
        // Calling lambda function
 
        // Print and display n the console
        System.out.println("Factorial of 5 : " + f.fact(5));
    }
}

Factorial of 5: 120

Aquí, en este bloque, lambda declara una variable ‘res’, for loop y tiene una declaración de retorno que es legal en el cuerpo de lambda.

Ejemplo 2:

// Java Program to illustrate Block Lambda expression
 
// Importing all input output classes
import java.io.*;
 
// Interface
// Functional interface named 'New'
interface New {
 
    // Boolean function to check over
    // natural number depicting calendar year
 
    // 'n' deepicting year is
    // passed as an parameter
    boolean test(int n);
}
 
// Class
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // block lambda
        // This block lambda checks if the
        // given year is leap year or not
        New leapyr = (year) ->
        {
            // Condition check
            // If year is divisible by 400 or the
            // year is divisible by 4 and 100 both
            if (((year % 400 == 0)
                 || (year % 4 == 0) && (year % 100 != 0)))
 
                // Returning true as year is leap year
                return true;
            else
 
                // Returning false for non-leap years
                return false;
        };
 
        // Calling lambda function over
        // custom input year- 2020
 
        // Condition check using the test()
        // defined in the above interface
        if (leapyr.test(2020))
 
            // Display message on the console
            System.out.println("leap year");
        else
 
            // Display message on the console
            System.out.println("Non leap year");
    }
}

leap year

Aquí, en este bloque, lambda tiene condiciones if-else y declaraciones de devolución que son legales en el cuerpo lambda.