Expresiones lambda¶

Las expresiones lambda es una característica importante que fue añadida en Java 8. Es muy útil, ayuda a iterar, filtrar y extraer datos de la colección. Una expresión lambda es un bloque corto de código que toma parámetros y devuelve un valor. Las expresiones lambda son similares a los métodos, pero no necesitan un nombre y se pueden implementar directamente en el cuerpo de un método. La expresiones lambda de Java son tratadas como una función, por lo que el compilador no crea un archivo .class.

La expresión lambda proporciona la implementación de una interfaz funcional. Una interfaz funcional es aquella que tiene un solo método abstracto. Las interfaces funcionales en Java incluyen la anotación @FunctionalInterface.

Sintaxis¶

Dado que las expresiones lambda son efectivamente solo métodos, las expresiones lambda pueden tomar parámetros como los métodos. La expresión lambda de Java consta de tres componentes.

Parámetros - lista de argumentos: una expresión lambda puede tener cero o cualquier número de argumentos.
Token de flecha: se utiliza para vincular la lista de argumentos y el cuerpo de la expresión.
Cuerpo: Contiene expresiones y declaraciones para la expresión lambda.

Las expresiones lambda se pueden almacenar en variables si el tipo de variable es una interfaz que tiene un solo método. La expresión lambda debe tener la misma cantidad de parámetros y el mismo tipo de retorno que ese método.

Cero parámetrosUn parámetroMúltiples parámetros

//() -> {body}
interface Saludo{
    public String say();
}
public class Main {
    public static void main(String[] args) {
        Saludo s=()->{
            return "Hola";
        };
        System.out.println(s.say());
    }
}

//p1 -> {body}
interface Saludo{
    public String say(String nombre);
}
public class Main {
    public static void main(String[] args) {
        //sin omitir paréntesis
        Saludo s = (nombre)->{
            return "Hola " + nombre;
        };
        System.out.println(s.say("Ginés"));
        // Omitiendo paréntesis
        Saludo s2 = nombre ->{
            return "Hola, " + nombre;
        };
        System.out.println(s2.say("Ginés"));
    }
}

//(p1, p2) -> {body}
interface Sumable{
    int add(int a,int b);
}
public class Main {
    public static void main(String[] args) {
        Sumable ad1=(a,b)->(a+b);
        System.out.println(ad1.add(10,20));
        // con tipo de datos
        Sumable ad2=(int a,int b)->(a+b);
        System.out.println(ad2.add(100,200));
    }
}

Tipo de datos

En ocasiones, puede ser necesario especificar tipos de parámetros para una expresión lambda si el compilador no puede inferir los tipos de parámetros del método de interfaz funcional con el que coincide la lambda.

(Coche coche) -> System.out.println("El coche es: " + coche.getName());

Devolviendo valores¶

En las expresiones lambda, si solo hay una sentencia, puede o no usar la palabra return. Pero si la expresión lambda tiene varias sentencias se debe poner la palabra return.

interface Sumable{
    int add(int a,int b);
}
public class Main {
    public static void main(String[] args) {
        // Lambda expression sin palabra clave return
        Sumable ad1 = (a,b)->(a + b);
        System.out.println(ad1.add(10,20));
        // Lambda expression con la palabra clave return
        Sumable ad2 = (a,b)->{
            return (a + b);
        };
        System.out.println(ad2.add(100,200));
    }
}

El compilador sabe que la expresión a + b es el valor de retorno de la expresión lambda (de ahí el nombre de expresiones lambda, ya que las expresiones devuelven un valor de algún tipo).

Con y sin expresión lambda¶

A la hora de programar, no deja de ser una herramienta más. El uso o no de ellas depende, en gran medida, de la pericia y/o gustos del programador.

Sin expresión lambdaCon expresión lambda

interface Saludo {
    public void saludar();
}
public class LambdaExpressionExample {
    public static void main(String[] args) {
        String nombre = "Luffy";
        //sin expresiones lambda, Saludo se implementa usando clases anónimas
        Saludo s = new Saludo(){
            public void saludar(){System.out.println("Hola " + nombre);}
        };
        s.saludar();
    }
}

@FunctionalInterface //Esto es opcional
interface Saludo {
    public void saludar();
}
public class LambdaExpressionExample2 {
    public static void main(String[] args) {
        String nombre = "Luffy";
        //con expresiones lambda
        Saludo s2 = ()-> {
            System.out.println("Hola " + nombre);
        };
        s2.saludar();
    }
}

Crear una expresión lambda a partir de un método¶

Para definir una expresión lambda de un método que no está definido en ninguna interfaz funcional, tenemos que utilizar la clase Function. A la clase Function se le especifican dos tipos de parámetros entre <>, el primero es el parámetro de entrada de la función, y el segundo es el parámetro de salida que devuelve la función o método.

ProgramaciónEjecución

Function<String, Integer> funcionLambda = (s) -> {
    int total = 0;
    for (int i = 0; i < texto.length(); i++) {
        total+=texto.charAt(i);
    }
    return total;
};

System.out.println(funcionLambda.apply("Programación"));

Actividades¶

AC 809 (RA3 / CE3f CE3g CE3i / IC1 / 3p). Transforma la siguiente clase anónima en una expresión lambda y crea código de prueba para usarla.

Runnable runnable = new Runnable() {
    @Override
    public void run() {
        String texto = "Vamos a crear un array";
        String[] partes = texto.split(" ");
        for (String parte: partes) {
            System.out.println(part);
        }
    }
};

AP 810 (RA3 / CE3f CE3g CE3i / IC1 / 3p).Transforma el siguiente método en una expresión lambda:

public static String caracteresPares(String texto) {
    StringBuilder sb = new StringBuilder();

    for (int i = 0; i < texto.length(); i++) {
        if (i % 2 == 0) {
            sb.append(texto.charAt(i));
        }
    }
    return sb.toString();
}

Escribe código para ejecutar la función del ejercicio anterior si se le pasa el siguiente texto:”1234567890”.