Haga coincidir Lambdas con interfaces en Java

Uno de los temas más populares e importantes es la expresión lambda en Java, pero antes de pasar directamente a nuestra discusión, veamos algunas cosas importantes. Comenzando con las interfaces en java como interfaces, están los tipos de referencia que son similares a las clases pero que contienen solo métodos abstractos. Esta es la definición de interfaz que teníamos antes de Java 1.8. Como antes de la versión 1.8 de Java, estamos usando cualquier versión, las interfaces son de tres tipos, a saber, como se indica a continuación:

• Interfaz normal
• Interfaz con múltiples métodos.
• Interfaz de marcador (las interfaces no contienen ningún método).

A partir de 1.8, todas las interfaces SAM (método abstracto único) se denominan interfaz funcional.

Interfaz funcional: la interfaz funcional es una interfaz que contiene exactamente un método abstracto, pero el punto importante es recordar que puede tener cualquier cantidad de métodos predeterminados o estáticos junto con los métodos de clase de objeto, ya que esto es lo que más confunde a los programadores.

Ejemplo:

// Java Program to Illustrate Functional Interface
 
// Importing required classes
import java.io.*;
 
// Interface
@FunctionalInterface
interface display {
 
    // Attribute
    void show(String msg);
 
    // Method
    // To compute the sum
    default int doSum(int a, int b) { return a + b; }
}
 
// Main class implementing the above interface
class GFG implements display {
 
    // Overriding the existing show() method
    @Override
 
    public void show(String msg)
    {
 
        // Print message
        System.out.println(msg);
    }
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating object of class inside main()
        GFG object = new GFG();
 
        // Calling show() method in main()
        object.show("Hello World!");
 
        // Print statement
        System.out.println(object.doSum(2, 3));
    }
}

Hello World!
5

Además, ahora analicemos cuáles son las clases anónimas. La clase anónima solo se crea para un uso único, no podemos reutilizarla. La pregunta que debe hacerse es ¿por qué necesitamos este tipo de clase? En algunos escenarios, como cuando nuestro único propósito es anular un método, puede usarlo. Ahora, otra ventaja de esto es que con la ayuda de esto podemos instanciar la interfaz muy fácilmente.

Ejemplo: suponga que desea reservar un taxi 

// Java Program to Illustrate Functional Interface
// With the Usage of Anonymous class
 
// Importing input output classes
import java.io.*;
 
// Interface
@FunctionalInterface
interface Cab {
 
    void bookCab();
}
 
// Main class
class GFG {
 
    // Method 1
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating object of above functional interface
        Cab cab = new Cab() {
            // Method 2
            // Overriding above bookCab() method
            @Override public void bookCab()
            {
 
                // Print statement
                System.out.println(
                    "Booking Successful!! Arriving Soon!!");
            }
        };
 
        cab.bookCab();
    }
}

Booking Successful!! Arriving Soon!!

Ahora es el momento adecuado para discutir las expresiones lambda en Java. Es una de las características importantes de Java 8. De hecho, las expresiones Lambda son el enfoque fundamental para la programación funcional en Java. Es una función anónima que no tiene nombre y no pertenece a ninguna clase. Esto en sí mismo es un gran tema que se ha discutido antes. Y debe tener una idea al respecto antes de saber de lo que estamos hablando.

Ahora hemos terminado de discutir todos los conceptos antes de aterrizar en ¿cómo podemos hacer coincidir la expresión lambda con la interfaz?

• La expresión Lambda solo funciona con interfaces funcionales en Java.
• Lambda expression proporciona una forma clara y concisa de representar una interfaz de método a través de una expresión.
• Proporciona la implementación de una interfaz funcional y simplifica el desarrollo de software.
• Podemos eliminar fácilmente el código repetitivo con la ayuda de la expresión Lambda.

Sintaxis:  

Parameter  -> expression body

Veamos nuestro código de una manera diferente porque ya hemos visto un ejemplo de clase anónima antes, ya que aquí creamos una lista de enteros y queremos ordenarlos según su último dígito.

Ejemplo 

// Java Program Without Using Lambda Expression
 
// Importing all utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // main driver method
    public static void main(String[] args)
    {
 
        // Creating an List of integer type
        List<Integer> list = Arrays.asList(
            234, 780, 451, 639, 456, 98, 75, 43);
 
        // Printing List before sorting
        System.out.println("Before Sorting");
 
        for (int i : list)
            System.out.print(i + " ");
 
        System.out.println();
 
        // Comparator is a functional interface
        // which is helps to sort object
        Collections.sort(list, new Comparator<Integer>() {
            // Overriding the existing compare method
            @Override
            public int compare(Integer a1, Integer a2)
            {
 
                return a1 % 10 > a2 % 10 ? 1 : -1;
            }
        });
 
        // Printing the list after sorting
        System.out.println("After Sorting");
 
        for (int i : list)
            System.out.print(i + " ");
 
        System.out.println();
    }
}

Before Sorting
234 780 451 639 456 98 75 43 
After Sorting
780 451 43 234 75 456 98 639 

Características de la expresión Lambda 

• Declaración de tipo opcional
• Paréntesis opcional alrededor de los parámetros.
• Llaves opcionales para una línea de código.
• Palabra clave de retorno opcional.

La expresión lambda puede tomar parámetros como un método.

Ejemplo 1 Expresión lambda con parámetro cero 

import java.io.*;
 
interface Display{
  void show();
}
 
class GFG{
   
  public static void main(String[] args){
   
    Display display= ()->System.out.println("Welcome");
     
    display.show();
      
  }
}

Welcome

Ejemplo 2: Expresión lambda con varios parámetros

// Java Program to Illustrate Lambda Expression
// with Multiple Parameter
 
// Importing required classes
import java.util.*;
 
// Main class
class GFG {
 
    // main driver method
    public static void main(String[] args)
    {
 
        // Creating a List of integer type
        List<Integer> list
            = Arrays.asList(24, 346, 78, 90, 21, 765);
 
        // Printing before sorting
        System.out.println("Before sorting.");
 
        for (int i : list)
            System.out.print(i + " ");
 
        System.out.println();
 
        // Sort the integers based on second digit
        Collections.sort(list, (a1, a2) -> {
            return a1 % 10 > a2 % 10 ? 1 : -1;
        });
 
        // Printing after sorting
        System.out.println("After sorting.");
 
        for (int i : list)
            System.out.print(i + " ");
 
        System.out.println();
    }
}

Before sorting.
24 346 78 90 21 765 
After sorting.
90 21 24 765 346 78