Expresiones Lambda 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 la única función abstracta y, por lo tanto, implementan interfaces funcionales.

Las expresiones lambda se agregan en Java 8 y proporcionan las siguientes funcionalidades.

Habilite para tratar la funcionalidad como un argumento de método o el código como datos.
Una función que se puede crear sin pertenecer a ninguna clase.
Una expresión lambda puede transmitirse como si fuera un objeto y ejecutarse a pedido.

// Java program to demonstrate lambda expressions
// to implement a user defined functional interface.
  
// A sample functional interface (An interface with
// single abstract method
interface FuncInterface
{
    // An abstract function
    void abstractFun(int x);
  
    // A non-abstract (or default) function
    default void normalFun()
    {
       System.out.println("Hello");
    }
}
  
class Test
{
    public static void main(String args[])
    {
        // lambda expression to implement above
        // functional interface. This interface
        // by default implements abstractFun()
        FuncInterface fobj = (int x)->System.out.println(2*x);
  
        // This calls above lambda expression and prints 10.
        fobj.abstractFun(5);
    }
}

Producción:

Sintaxis:

 lambda operator -> body

donde el operador lambda puede ser:

Parámetro cero:

() -> System.out.println("Zero parameter lambda");

Un parámetro: –
```
(p) -> System.out.println("One parameter: " + p);
```
No es obligatorio usar paréntesis, si el tipo de esa variable se puede inferir del contexto

Múltiples parámetros:

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

Tenga en cuenta: las expresiones lambda son como funciones y aceptan parámetros como funciones.

// A Java program to demonstrate simple lambda expressions
import java.util.ArrayList;
class Test
{
    public static void main(String args[])
    {
        // Creating an ArrayList with elements
        // {1, 2, 3, 4}
        ArrayList<Integer> arrL = new ArrayList<Integer>();
        arrL.add(1);
        arrL.add(2);
        arrL.add(3);
        arrL.add(4);
  
        // Using lambda expression to print all elements
        // of arrL
        arrL.forEach(n -> System.out.println(n));
  
        // Using lambda expression to print even elements
        // of arrL
        arrL.forEach(n -> { if (n%2 == 0) System.out.println(n); });
    }
}

Producción :

Tenga en cuenta que las expresiones lambda solo se pueden usar para implementar interfaces funcionales. En el ejemplo anterior también, la expresión lambda implementa la interfaz funcional del consumidor .

Un programa Java para demostrar el funcionamiento de la expresión lambda con dos argumentos.

// Java program to demonstrate working of lambda expressions
public class Test
{
    // operation is implemented using lambda expressions
    interface FuncInter1
    {
        int operation(int a, int b);
    }
  
    // sayMessage() is implemented using lambda expressions
    // above
    interface FuncInter2
    {
        void sayMessage(String message);
    }
  
    // Performs FuncInter1's operation on 'a' and 'b'
    private int operate(int a, int b, FuncInter1 fobj)
    {
        return fobj.operation(a, b);
    }
  
    public static void main(String args[])
    {
        // lambda expression for addition for two parameters
        // data type for x and y is optional.
        // This expression implements 'FuncInter1' interface
        FuncInter1 add = (int x, int y) -> x + y;
  
        // lambda expression multiplication for two parameters
        // This expression also implements 'FuncInter1' interface
        FuncInter1 multiply = (int x, int y) -> x * y;
  
        // Creating an object of Test to call operate using
        // different implementations using lambda Expressions
        Test tobj = new Test();
  
        // Add two numbers using lambda expression
        System.out.println("Addition is " +
                          tobj.operate(6, 3, add));
  
        // Multiply two numbers using lambda expression
        System.out.println("Multiplication is " +
                          tobj.operate(6, 3, multiply));
  
        // lambda expression for single parameter
        // This expression implements 'FuncInter2' interface
        FuncInter2 fobj = message ->System.out.println("Hello "
                                                 + message);
        fobj.sayMessage("Geek");
    }
}

Producción:

Addition is 9
Multiplication is 18
Hello Geek

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 devolución 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. .

Por favor vea esto . para una aplicación.

Este artículo es una contribución de Sampada Kaushal . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta