Java: parámetros de expresiones lambda

Las expresiones lambda son funciones anónimas. Estas funciones no necesitan un nombre o una clase para ser utilizadas. Las expresiones lambda se agregan en Java 8. Las expresiones lambda básicamente expresan instancias de interfaces funcionales Una interfaz con un único método abstracto se denomina interfaz funcional. Un ejemplo es java.lang.Runnable.

Las expresiones lambda implementan solo una función abstracta y, por lo tanto, implementan interfaces funcionales. La interfaz predicada es un ejemplo de una interfaz funcional que tiene solo un método abstracto llamado test().

Ilustración:

interface Predicate
{
    ......
    abstract boolean test(T t)
}

Lo anterior es una interfaz funcional que tiene una prueba de método abstracto que recibe solo un parámetro de tipo T y devuelve un valor booleano. Este método es un método genérico que toma un parámetro de tipo. Esta interfaz se puede implementar en cualquier parte de un programa usando una expresión lambda en lugar de crear clases con múltiples funciones. Por ejemplo, para implementar una interfaz ejecutable utilizada solo para subprocesos múltiples, se necesita implementar solo un método run(). Luego está la interfaz comparable que se puede implementar usando el método compare().

Puntos importantes:

• El cuerpo de una expresión lambda puede contener cero, una o más declaraciones.
• Cuando hay una sola declaración, los corchetes no son obligatorios y el tipo de retorno de la función anónima es el mismo que el de la expresión del cuerpo.
• Cuando hay más de una instrucción, estas deben estar encerradas entre corchetes (un bloque de código) y el tipo de retorno de la función anónima es el mismo que el tipo del valor devuelto dentro del bloque de código, o nulo si no se devuelve nada. .

Estos son para expresiones lambda de una sola línea que tienen un tipo de retorno nulo.

Tipo 1: Sin parámetro.

Sintaxis:

() -> System.out.println("Hello");

Toma interfaz de la siguiente forma:

interface Test1
{
    void print()
}

Tipo 2: parámetro único.

Sintaxis:

(p) -> System.out.println(p);

No es obligatorio usar paréntesis si el tipo de esa variable se puede inferir del contexto

Toma interfaz de la siguiente forma:

interface Test2
{
    void print(Integer p)
}

El tipo y el tipo de retorno de las lambdas se infieren automáticamente.

Tipo 3: parámetros múltiples

(p1, p2) -> System.out.println(p1 + " " + p2);

No es obligatorio usar paréntesis si el tipo de esa variable se puede inferir del contexto

Toma interfaz de la siguiente forma:

interface Test3
{
    void print(Integer p1, Integer p2)
}

El tipo y el tipo de retorno de las lambdas se infieren automáticamente.

Ahora, hemos terminado de discutir el concepto teórico, ahora pasemos a la parte de implementación. Entonces, aquí principalmente discutiremos los códigos para los tres tipos anteriores como se discutió anteriormente:

Nota: el método forEach() es una interfaz iterable que se usa para iterar a través de una colección. Aquí toma un argumento de interfaz de tipo Consumidor. Esta es una interfaz funcional que tiene solo un método abstracto llamado accept(). Dado que es una interfaz funcional, se puede pasar una expresión lambda.

Por lo tanto, si concluimos lo anterior 

Ejemplo 1: expresión lambda sin parámetros

// Java code to illustrate lambda expression
// without parameters
 
// functional interface
// without parameters
interface Test1 {
    void print();
}
 
class GfG {
    // functional interface parameter is passed
    static void fun(Test1 t) { t.print(); }
    public static void main(String[] args)
    {
        // lambda expression is passed
        // without parameter to functional interface t
        fun(() -> System.out.println("Hello"));
    }
}

Hello

Ejemplo 2: expresión Lambda de tipo 2 con un solo parámetro

// Java code to illustrate lambda expression
// with single parameter
 
// functional interface
// with one parameter of Integer type
interface Test2 {
    // The void type and the Integer type
    // is automatically inferred from here
    // and assigned to the lambda expression
    void print(Integer p);
}
 
class GfG {
    // takes lambda expression and a variable of
    // Integer type as arguments
    static void fun(Test2 t, Integer p)
    {
        // calls the print function
        t.print(p);
    }
    public static void main(String[] args)
    {
        // lambda expression is passed
        // with a single parameter
        // lambda expression is mapped to the
        // single argument abstract function in the
        // functional interface Test2
        fun(p -> System.out.println(p), 10);
    }
}

10

Ejemplo 3: Expresión Lambda de tipo 3 con múltiples parámetros

// Java code to illustrate lambda expression
// with multi parameters
 
// functional interface Test3
// with 2 parameter of Integer type
interface Test3 {
    // The void type and the Integer type
    // is automatically inferred from here
    // and assigned to the lambda expression
    void print(Integer p1, Integer p2);
}
 
class GfG {
    // takes parameter of Test3 type followed
    // by 2 integer parameters p1 and p2
    static void fun(Test3 t, Integer p1, Integer p2)
    {
        // calls the print function
        t.print(p1, p2);
    }
    public static void main(String[] args)
    {
        // lambda expression is passed
        // with two parameters
        // lambda expression is mapped to the
        // double argument abstract function in the
        // functional interface Test3
        fun((p1, p2)
                -> System.out.println(p1 + " " + p2),
            10, 20);
    }
}

10 20

Ejemplo 4: expresión lambda con dos parámetros

// Demonstrate a lambda expression that takes two parameters
 
interface NumericTest2{
   boolean test(int n, int d);
}
 
class GFG{
public static void main(String args[]){
 
  // The labda expression here determines if one number is the factor of another
  NumericTest2 isFactor= (n,d) -> (n%d)==0;
  if(isFactor.test(10,2))
    System.out.println("2 is the factor of 10");
   
  if(!isFactor.test(10,3))
    System.out.println("3 is not a factor of 10");
   
}
}

2 is the factor of 10
3 is not a factor of 10