He creado un meme :upside_down_face:

Cuando trabajas con programación funcional en Java, llega un momento en el que almacenar cada función en una variable resulta innecesario. Ahí es donde las lambdas cobran protagonismo: son funciones anónimas que existen solo en el fragmento de código donde se usan, sin nombre ni referencia posterior. Comprender su sintaxis y cuándo aplicarla es fundamental para escribir código limpio y expresivo.
¿Qué son las lambdas y por qué usarlas?
Una lambda es una función que no está almacenada en ningún lugar del código [01:10]. Si defines una operación dentro de un forEach, por ejemplo, esa lógica vive únicamente en ese punto. No puedes reutilizarla después porque no tiene nombre ni referencia.
El ejemplo más directo es recorrer una lista de cursos con forEach y pasar una lambda que imprima cada elemento por pantalla [02:00]. Aunque podrías usar un operador de referencia como System.out::println, la versión lambda deja claro que estás definiendo comportamiento en el acto.
¿Cómo varía la sintaxis según los parámetros?
La sintaxis de las lambdas cambia dependiendo de cuántos parámetros reciba la función y de cuántas líneas tenga el cuerpo.
¿Cómo se escribe una lambda sin argumentos?
Cuando tu functional interface no recibe ningún parámetro, la sintaxis usa paréntesis vacíos seguidos de la flecha [03:30]:
java () -> 42
Esto indica que la lambda no necesita datos de entrada y retorna directamente el valor. Java infiere el retorno sin necesidad de escribir return.
¿Qué sintaxis aplica con un solo parámetro?
Con un Predicate, por ejemplo, la lambda recibe un solo dato. Basta con nombrar el parámetro, agregar la flecha y escribir la expresión [04:40]:
java usarPredicado(text -> text.isEmpty());
No hace falta declarar el tipo de dato ni la palabra return. Los predicados siempre devuelven un booleano, así que Java entiende que text.isEmpty() es el valor de retorno.
¿Y cuando hay dos o más parámetros?
Al trabajar con una BiFunction, necesitas encerrar los parámetros entre paréntesis [05:50]:
java usarBiFunction((x, y) -> x + y);
Esta estructura recibe dos valores y devuelve un resultado directamente. La flecha (->) se forma con un guion seguido del signo mayor que; algunos editores la renderizan como un solo carácter visual, pero en realidad son dos caracteres separados [06:30].
¿Qué pasa cuando el cuerpo necesita varias líneas?
Si tu lambda requiere más de una operación, agregas llaves (braces) para definir un cuerpo más complejo [07:00]:
java usarBiFunction((x, y) -> { System.out.println("x: " + x + ", y: " + y); return x - y; });
return de forma explícita.También existe el caso de una función que no recibe parámetros y no retorna nada [08:20]. Para eso puedes crear una functional interface con un método void:
java usarNada(() -> { System.out.println("Hola, alumno"); });
Los paréntesis vacíos indican cero argumentos y las llaves contienen operaciones sin return, porque el tipo de retorno es void.
¿Se pueden declarar tipos explícitos en los parámetros?
Sí. Aunque no es habitual en proyectos del día a día, puedes escribir el tipo directamente [09:40]:
java usarBiFunction((Integer x, Integer y) -> x * y);
Un detalle importante: las functional interfaces operan sobre objetos, no sobre tipos primitivos como int, char o boolean [10:00]. Por eso debes usar Integer en lugar de int. Esta distinción entre tipos primitivos y sus clases envolventes (wrapper classes) es clave para evitar errores de compilación.
Al trabajar con listas, IntelliJ sugiere que el forEach necesita un Consumer de un tipo que extienda de la clase base, indicándolo con la palabra super [10:40]. Esto refleja que puedes generar lambdas que trabajen con subtipos, siempre que la lambda esté definida para el tipo correspondiente.
¿Ya estás usando lambdas en tus proyectos? Comparte en los comentarios qué sintaxis te resulta más natural y en qué situaciones prefieres un operador de referencia.
Cuando trabajas con programación funcional en Java, llega un momento en el que almacenar cada función en una variable resulta innecesario. Ahí es donde las lambdas cobran protagonismo: son funciones anónimas que existen solo en el fragmento de código donde se usan, sin nombre ni referencia posterior. Comprender su sintaxis y cuándo aplicarla es fundamental para escribir código limpio y expresivo.
Una lambda es una función que no está almacenada en ningún lugar del código [01:10]. Si defines una operación dentro de un forEach, por ejemplo, esa lógica vive únicamente en ese punto. No puedes reutilizarla después porque no tiene nombre ni referencia.
El ejemplo más directo es recorrer una lista de cursos con forEach y pasar una lambda que imprima cada elemento por pantalla [02:00]. Aunque podrías usar un operador de referencia como System.out::println, la versión lambda deja claro que estás definiendo comportamiento en el acto.
La sintaxis de las lambdas cambia dependiendo de cuántos parámetros reciba la función y de cuántas líneas tenga el cuerpo.
Cuando tu functional interface no recibe ningún parámetro, la sintaxis usa paréntesis vacíos seguidos de la flecha [03:30]:
java () -> 42
Esto indica que la lambda no necesita datos de entrada y retorna directamente el valor. Java infiere el retorno sin necesidad de escribir return.
Con un Predicate, por ejemplo, la lambda recibe un solo dato. Basta con nombrar el parámetro, agregar la flecha y escribir la expresión [04:40]:
java usarPredicado(text -> text.isEmpty());
No hace falta declarar el tipo de dato ni la palabra return. Los predicados siempre devuelven un booleano, así que Java entiende que text.isEmpty() es el valor de retorno.
Al trabajar con una BiFunction, necesitas encerrar los parámetros entre paréntesis [05:50]:
java usarBiFunction((x, y) -> x + y);
Esta estructura recibe dos valores y devuelve un resultado directamente. La flecha (->) se forma con un guion seguido del signo mayor que; algunos editores la renderizan como un solo carácter visual, pero en realidad son dos caracteres separados [06:30].
Si tu lambda requiere más de una operación, agregas llaves (braces) para definir un cuerpo más complejo [07:00]:
java usarBiFunction((x, y) -> { System.out.println("x: " + x + ", y: " + y); return x - y; });
return de forma explícita.También existe el caso de una función que no recibe parámetros y no retorna nada [08:20]. Para eso puedes crear una functional interface con un método void:
java usarNada(() -> { System.out.println("Hola, alumno"); });
Los paréntesis vacíos indican cero argumentos y las llaves contienen operaciones sin return, porque el tipo de retorno es void.
Sí. Aunque no es habitual en proyectos del día a día, puedes escribir el tipo directamente [09:40]:
java usarBiFunction((Integer x, Integer y) -> x * y);
Un detalle importante: las functional interfaces operan sobre objetos, no sobre tipos primitivos como int, char o boolean [10:00]. Por eso debes usar Integer en lugar de int. Esta distinción entre tipos primitivos y sus clases envolventes (wrapper classes) es clave para evitar errores de compilación.
Al trabajar con listas, IntelliJ sugiere que el forEach necesita un Consumer de un tipo que extienda de la clase base, indicándolo con la palabra super [10:40]. Esto refleja que puedes generar lambdas que trabajen con subtipos, siempre que la lambda esté definida para el tipo correspondiente.
¿Ya estás usando lambdas en tus proyectos? Comparte en los comentarios qué sintaxis te resulta más natural y en qué situaciones prefieres un operador de referencia.
He creado un meme :upside_down_face:

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.
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.
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();
}
}
Osea una lambda no es lo mismo que una función creada por una interfaz?
LA MEJOR CLASE 😎