Uso de Expresiones Lambda en Java: Sintaxis y Aplicaciones

Clase 18 de 39 • Curso de Programación Funcional con Java SE

Resumen

¿Qué son y cómo se utilizan las funciones lambda en Java?

Las funciones lambda en Java son una herramienta poderosa que permite crear funciones anónimas, facilitando el manejo y manipulación de expresiones funcionales de manera clara y concisa. Estas funciones permiten introducir bloques de código más compactos que pueden ser evaluados en tiempo de ejecución sin necesidad de almacenarse bajo un nombre específico. Aprender a utilizar las funciones lambda correctamente es esencial para cualquier desarrollador que quiera emplear programación funcional en Java.

¿Por qué utilizar funciones lambda?

Las lambdas ofrecen varias ventajas:

Mitigan el uso de clases anónimas: Reducen el código redundante y evitan la creación de clases anónimas sin necesidad.
Simplifican el código: Permiten expresar comportamientos de manera compacta y clara.
Facilitan operaciones en colecciones: Trabajar con streams y otras APIs que utilizan funciones de orden superior es más sencillo y directo.

¿Cómo es la sintaxis de las funciones lambda?

La sintaxis básica de las funciones lambda se puede descomponer en los siguientes elementos:

Parámetros: Se colocan dentro de paréntesis. En caso de varios parámetros, se separan por comas.
Operador 'flecha' ->: Separa los parámetros del cuerpo de la función.
Cuerpo: Puede ser una sola expresión o un bloque de sentencias delimitado por llaves si se trata de múltiples expresiones.

Ejemplo de una función lambda sin parámetros:

Runnable noArguments = () -> System.out.println("Hello World");

Ejemplo de una función lambda con un parámetro y una sola expresión:

Consumer<String> greet = name -> System.out.println("Hello, " + name);

Función lambda con múltiples parámetros y bloque de código:

BiFunction<Integer, Integer, Integer> add = (a, b) -> {
    System.out.println("Adding numbers: " + a + " + " + b);
    return a + b;
};

¿Cómo funcionan las interfaces funcionales en Java?

Las lambdas se implementan generalmente mediante interfaces funcionales, que son interfaces definidas con una sola función abstracta. Esto permite a Java inferir el tipo de la lambda automáticamente, reduciendo así verborrea de código.

Creación de una interfaz funcional:

@FunctionalInterface
public interface Operate {
    int operation(int a, int b);
}

Usarla con una lambda:

Operate addition = (a, b) -> a + b;

¿Cómo se aplican las lambdas en funciones de orden superior?

Java permite que las funciones sean pasadas como argumentos gracias a las lambdas, comúnmente conocidas como higher-order functions. Estas funciones pueden recibir una lambda como argumento o devolver una.

Ejemplo de función de orden superior:

public static void executeOperation(Operate op, int x, int y) {
    int result = op.operation(x, y);
    System.out.println("Result: " + result);
}

executeOperation((a, b) -> a - b, 10, 5); // Resultado: 5

¿Qué consideraciones debemos tener al usar lambdas?

Uso de tipos primitivos y tipo de retorno: Al definir lambdas, es importante notar que trabajan sobre objetos y no sobre tipos primitivos. Es necesario utilizar clases envolventes como Integer en lugar de int.
Claridad y legibilidad del código: Si bien las lambdas pueden hacer el código más conciso, es importante mantener la legibilidad del código. Esto puede requerir que a veces definamos explícitamente los tipos involucrados.

Al adoptar las lambdas y otras características de la programación funcional, los desarrolladores de Java pueden escribir código más limpio y eficiente, simplificando operaciones que de otra manera serían mucho más complejas. ¡Así que sigue explorando y mejorando tus habilidades con las lambdas en Java!

Cristobal Vega

student•

He creado un meme :upside_down_face:

Sebastián Andrade

student•

Hola Jhon! No se si sea algo tarde, pero la razon por la cual se trabaja con Objetos como tal y no con tipos de datos primitivos es porque las interfaces funcionales (Function, Predicate, Consummer, etc) Son interfaces genericas (reciben un tipo de dato en la definicion de la interfaz: Function<Integer, String>) Esto de "generics" es todo un tema de Java, bastante amplio, la verdad es algo dificil de definir pero es basicamente permitir que en el momento de crear una instancia de la clase (o definir la interfaz) se pueda setear uno o varios tipos de datos que la clase internamente usará para definir ciertos metodos. Te dejo aqui una documentacion en la cual lo podrás ver en uso y construir tu propia definicion mental xd

Sebastián Andrade

student•

definir no. implementar*

Cristian Felipe Patiño Cáceres

student•

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

Sergio Fernández Salazar

student•

Que buen aporte, Gracias.

Antonio Madrid

student•

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.

Vladimir Olek Mallqui Perez

student•

javascript me preparo para este momento ;D

William Schnaider Torres Bermon

student•

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.

Enable to treat functionality as a method argument, or code as data.
A function that can be created without belonging to any class.
A lambda expression can be passed around as if it was an object and executed on demand.

Oscar Daniel Betancourt Ortega

student•

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

Diego Forero

Team Platzi•

Es una función que tiene el IDE que usa el profesor se llama font ligatures, lo que hace es mostrar como flecha cuando escribes -> pasa similar con símbolos como !=, == o >=

Oscar Daniel Betancourt Ortega

student•

Gracias!

Jean Nuñez

student•

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

Alejandro Sebastian Dubon Estrada

student•

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

Ivan Castaneda Contreras

student•

Osea una lambda no es lo mismo que una función creada por una interfaz?

Robert Vásquez

student•

No, las lambdas basicamente simplifican la forma de crear funciones.

Luis Gomero

student•

LA MEJOR CLASE 😎

Juan José Álvarez Pérez

student•

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.

Robert Alexander Machado Espinoza

student•

vengo de JavaScript y esto me recuerda a las arrow functions... pero incluso esas 'nuevas funciones' agregas a Java 8 son funciones standard dentro de JavaScript solo que con pequeñisimas variasiones de sintaxis