Expressões lambda basicamente expressam instâncias de interfaces funcionais (uma interface com método abstrato único é chamada de interface funcional. Um exemplo é java.lang.Runnable). Expressões lambda implementam a única função abstrata e, portanto, implementam interfaces funcionais

As expressões lambda são adicionadas no Java 8 e fornecem as funcionalidades abaixo.

• Ative para tratar a funcionalidade como um argumento de método ou o código como dados.
• Uma função que pode ser criada sem pertencer a nenhuma classe.
• Uma expressão lambda pode ser passada como se fosse um objeto e executada sob demanda.

// 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);
    }
}

Saída:

10

Sintaxe:

 lambda operator -> body

onde o operador lambda pode ser:

• Parâmetro zero:

  () -> System.out.println ("Zero parâmetro lambda");

• Um parâmetro: -

  (p) -> System.out.println ("Um parâmetro:" + p);

  Não é obrigatório o uso de parênteses, se o tipo dessa variável pode ser inferido a partir do contexto

• Parâmetros múltiplos:

  (p1, p2) -> System.out.println ("Parâmetros múltiplos:" + p1 + "," + p2);

Observe: as expressões lambda são como funções e aceitam parâmetros como funções.

// 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); });
    }
}

Saída :

1
2
3
4
2
4

Observe que as expressões lambda só podem ser usadas para implementar interfaces funcionais. Também no exemplo acima, a expressão lambda implementa a Interface Funcional do Consumidor .

Um programa Java para demonstrar o funcionamento da expressão lambda com dois 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");
    }
}

Saída:

Addition is 9
Multiplication is 18
Hello Geek

Pontos importantes:

• O corpo de uma expressão lambda pode conter zero, uma ou mais declarações.
• Quando há uma única instrução, as chaves não são obrigatórias e o tipo de retorno da função anônima é o mesmo da expressão do corpo.
• Quando houver mais de uma instrução, elas devem ser colocadas entre colchetes (um bloco de código) e o tipo de retorno da função anônima é o mesmo que o tipo do valor retornado no bloco de código, ou nulo se nada for retornado .

Por favor, veja isso . para um aplicativo.

Este artigo foi contribuído por Sampada Kaushal . Se você gosta de GeeksforGeeks e gostaria de contribuir, você também pode escrever um artigo usando contribute.geeksforgeeks.org ou enviar o seu artigo para contribute@geeksforgeeks.org. Veja o seu artigo na página principal do GeeksforGeeks e ajude outros Geeks.

Escreva comentários se encontrar algo incorreto ou se quiser compartilhar mais informações sobre o tópico discutido acima.