Uso de Expresiones Lambda en Java: Sintaxis y Aplicaciones

He creado un meme 🙃

Estructura Funciones Lambda

Lambda que recibe un parámetro y realiza una operación simple:

text -> System.out.println(text)

Lambda que no recibe parámetros y realiza una operación de retorno simple:

() -> "Hello world"

Lambda que recibe un solo parámetro y realiza una operación de retorno simple:

x -> x % 2 == 0

Lambda que recibe varios parámetros:

(x, y) -> x * y

Lambda que realiza varias operaciones:

(x, y) -> {
  System.out.println("Suma de x: " + x + ", y: " + y);
  System.out.println(x + y);
}

Lambda que realiza varias operaciones y retorno:

(x, y) -> {
  System.out.println("Suma de x: " + x + ", y: " + y);
  return x + y;
}

Lambda con tipado de parámetros:

(String text) -> System.out.println(text);

Lambda que retorna un dato que ocupa varias lineas:

() -> (
  "<div class='movieSearch'>" +
  " <div class='movie-close'>" +
  "   <button class='movie-close-button'>" +
  "     <figure>" +
  "       <img src='src/images/close.png'>" +
  "     </figure>" +
  "   </button>" +
  " </div>" +
  "</div>"
)

Lambda que no recibe por parámetros nada y tampoco retorna nada:

() -> {}

() -> System.out.println("No recibo nada")

() -> {
  System.out.println("No recibo nada");
  System.out.println("No retorno nada");
}

Sintaxis de lambdas

Si la lambda NO recibe argumentos:
( ) -> operación

Si la lambda recibe 1 argumento:
_argumento -> operación
( argumento ) -> operación_

Si la lambda recibe mas de 1 argumento:
( argumento1, argumento2) -> operación

Si la lambda recibe varias operaciones:
( ) -> { operacion1; return operación2; }
argumento -> { operacion1; return operacion2; }
( argumento ) -> { operacion1; return operacion2; }
( argumento1, argumento2) -> { operacion1; return operacion2 }

Si la lambda tiene mas de una operación debemos retornar un valor mediante.
return

Pero si NO devuelve nada, solo hay que indicar el tipo de entrada vacío.

( ) -> { operación }

Para evitar errores es mejor usar
( ) -> { operación }
para cualquier caso.

javascript me preparo para este momento ;D

Lambda expressions basically express instances of functional interfaces (An interface with single abstract method is called functional interface. An example is java.lang.Runnable). lambda expressions implement the only abstract function and therefore implement functional interfaces

Lambda expressions are added in Java 8 and provide below functionalities.

1. Enable to treat functionality as a method argument, or code as data.

2. A function that can be created without belonging to any class.

3. A lambda expression can be passed around as if it was an object and executed on demand.

Cómo puedo agregar esa configuración a mi teclado para la flecha?

Las funciones lambdas solo esta presente en donde se crean y son funciones cortas y simples

package com.platzi.functional._08_lambda;

import com.platzi.functional._06_reference_operator.NombresUtils;

import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Predicate;

public class Sintaxis {
    public static void main(String[] args) {
        List<String> cursos = NombresUtils.getList("Java", "Functional");

        // Esta es una lambda que solo retorna la impresion de un curso
        cursos.forEach(curso -> System.out.println(curso));

        // Una lambda en su minima expresion (solo retorna el 2)
        usarZero(() -> 2);

        // El predicate retorna true o false
        usarPredicado((texto) -> texto.isEmpty());

        // Puede recibir 2 parametros
        usarBiFunction((x, y) -> x * y);

        // Con mas operaciones se debe especificar donde esta el return
        usarBiFunction((x, y) -> {
            System.out.println(x + " + " + y);
            return x + y;
        });

        // Cuando no se recibe nada y no se retorna ningun resultado
        usarNada(() -> {
            System.out.println("No hago nada, porque no retorno nada");
        });

        // Se pueden especificar los tipos de datos pero no es muy comun encontrarlo en proyectos
        usarBiFunction((Integer x, Integer y) -> x * y);

    }

    // estas funciones son high order functions usadas para poder pasar la funciones lambda como parametros
    static void usarZero(ZeroArguments zeroArguments){

    }

    static void usarPredicado(Predicate<String> predicate){

    }

    static void usarBiFunction(BiFunction<Integer, Integer, Integer> biFunction){

    }

    static void usarNada(OperarNada operarNada){

    }

    @FunctionalInterface
    interface ZeroArguments{
        int get();
    }

    @FunctionalInterface
    interface OperarNada{
        void nada();
    }
}

LA MEJOR CLASE 😎

Sintaxis de las funciones lambda

⠀
Las funciones Lambda son funciones anónimas, es decir, no están asignadas a variables (Function, Predicate, Consumer, etc), sino que se definen en el momento en que son usadas y al no nombrarse no es posible volverlas a usar.
⠀
Por ejemplo, para mostrar una lista de String, es posible utilizar el método forEach que para cada elemento de la lista aplicará la expresión pasada como parámetro.

List<String> numeros = Arrays.asList("uno", "dos", "tres");

numeros.forEach(texto -> System.out.println(texto));

La sintáxis de las Lambdas varía dependiendo de su estructura:

• Cantidad de paráetros: Cuando no recibe parámetros o recibe dos o más, se deben poner entre paréntesis (x, y) -> ..., pero si sólo es uno no son necesarios.
• Cantidad de líneas: Si sólo se necesita una línea, puede escribirse a continuación de la -> y no es necesario usar ;. Si son dos o más lineas, se deben usar llaves -> { ... } y ; en cada línea.
• Retorn o no un dato: Si sólo se necesita una línea para retornar el dato no es necesario usar return.

✅

Justo iba a preguntar que pasaba si la logica era mas grande y fue solo agregar las llaves. Gracias!

Esto me recuerda a las Arrow Functions de Javascript, y hasta su sintaxis es muy similar.

Bien explicado y detallado como para entender… gracias.

¿Alguno sabe como obtener los {} de colores que tiene el profe por jerarquia? es muy util a la hora de debugear

las funciones al ser interfaces trabajan directamentes en objetos mo trabajan sobre de tipos de datos primitivos

Excelente información

Entonces bajo lo que vimos en el video en caso de requerirlo puedo hacer una clase que tenga los métodos “usarAlgo” y llamarlos para crear lamdas sin tener que hacer la declaración larga BiFunction<Integer,Integer,Integer> s = (x,y) -> x*y;

IsEmpty (si es vacio) devuelve un valor de tipo booleano que indica true si el tamaño de la cadena es igual a 0

Gracias por los ejempos… queda mas claro con ello 😃

Muchas gracias por la clase instructor Sinuhé, tendré en cuenta esta herramienta cuando quiera añadir funcionalidades de forma rápida y se usen en sola una ocasión, además de tener cuidado de usar objetos en vez de tipos de datos primitivos para que no se generen errores.

Genial.

Las lambdas no se almacenan en ningún lado, sólo están para una tarea específica.

(x -> x * 2)

Las funciones son interfaces, por lo cual no aceptan Tipo de Dato PRIMITIVO, sino tipo de datos OBJETOS o WRAPPER.

Maneras creativas de definir nuestro código que nos permite realizar operaciones que solo se usaran para esa parte especifica del código, pero soy más partidario de definir los tipos de datos para que sea mucho más fácil de entender el código, aunque con solo leer el código veríamos cual es el tipo pero es más fácil solo verlo.