Lambdas con Java 8

Clase 18 de 23 • Curso de Java para APIs REST 2016

Charles Córdova

student•

Me gusto el curso, pero no debería llamarse "curso profesional de java", mejor quedaría "Introducción profesional a Java", Platzi poner mas énfasis en pilotear internamente los cursos, hagan pequeños grupos y utilizar la tecnología expuestas en productos. Nos haría muy felices saber que utilizan JAVA! Saludos.

Cesar David Ramírez Dimaté

student•

No necesariamente. Creo que más de uno estaba pensando que el enfoque del curso profesional de Java iba a estar enfocado a lo de siempre… Glassfish, JSF (con Primefaces), JDBC, En otras palabras, algo como esto Curso de Desarrollo con Java EE 6.

Este es otro enfoque, pero no quiere decir que sea profesional. Es lo actual de Java, no el pasado. Utilizar Maven o Gradle para ejecutar y subir nuestros proyectos. Crear un API Rest para manejar un JSON y ver como se puede hacer un CRUD a través de esto.

Ernesto Cantu

student•

Las interfaces funcionales son aquellas interfaces que solo tienen un método, como por ejemplo Runnable()

interface Runnable{  
  
   public void run();  
}

Las implementaciones anónimas son aquellas que no tienen una implementación definida, y se definen al momento de ser declaradas. En el caso de runnable podemos hacer una implementación anónima de la siguiente forma:

Runnable runnable = new Runnable(){  
  
  
  
}

Ernesto Cantu

student•

Jeje, no se que le pasó...sigo

Runnable runnable = new Runnable(){  
    public void run(){  
        //Implementación  
    }  
}

Las lambdas trabajan por lo general con interfaces funcionales

Cesar David Ramírez Dimaté

student•

Así es. Lo que tengo entendido es que lambda funciona para clases que son interfaces y se puede implementar o no un método abstracto. En el caso de crear un hilo con Runnable, o no, en el cso de Compare.

Eder Weiß

student•

Las expresiones lambdas Java son similares a los Ruby block.

Carlos Parra

student•

Tratar nuestro código como si fueran datos. :D

Carlos Parra

student•

Enviar funciones como argumentos de los metodos.

Cesar David Ramírez Dimaté

student•

Ejercicio del video

LambdaExpressionMain.java

package platzi;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaExpressionMain {
	public static void main(String args []) {
		/**
		 * Crear un hilo (Thread) y ejecutar el método abstracto run().
		 * Antes: Defino una clase nueva MyThread.
		 * 
		 * -- Opción 1 -- 
		 * public interface Runnable {
		 *     public abstract void run();
		 * }
		 * 
		 * public class MyThread implements Runnable {
		 *     @Override
		 *     public void run() {
		 *         System.out.println("Lamda Platzi.");
		 *     }
		 * }
		 * 
		 * -- Opción 2 -- 
		 * Runnable miMetodo() {
		 *     return new Runnable() {
		 *         public void run() {
		 *             System.out.println("Lamda Platzi.");
		 *         }
		 *     }
		 * }
		 * 
		 * Ahora: Con Lambda...
		 *     - () : Utiliza un método sin argumentos. El método run().
		 *     - -> : Funcionalidad a colocar ald método.
		 *     - Implementar el método abstracto de la Interface.
		 */
		Runnable runnable = () -> System.out.println("Lamda Platzi.");
		runnable.run();
		
		/**
		 * Comparator: Es una clase que compara objetos.
		 * 		- (Mensaje m1, Mensaje m2) : Utiliza un método con argumentos. El método compare().
		 */
		Comparator<Mensaje> c = (Mensaje m1, Mensaje m2) -> m1.getSize() - m2.getSize();
		
		// Convierte un array a una lista (Objeto Mensaje).
		List<Mensaje> mensajes = Arrays.asList(
				new Mensaje("Mensaje mas largo que existe"),
				new Mensaje("Mensaje menos largo"),
				new Mensaje("Mensaje realmente mas largo que existe"));
		
		System.out.println("\nDisorderly");
		// ForEach sin Lambda
		for (Mensaje mensaje : mensajes) {
			System.out.println(mensaje.getSize());
		}
		
		/**
		 *  Ordena la lista de objetos de menor a mayor según su tamaño.
		 *  El método sort utiliza un ciclo, compara objetos a pares y cambia su posición.
		 */
		mensajes.sort(c);
		
		System.out.println("\nOrdered");
		// ForEach con Lambda
		mensajes.forEach(mensaje -> System.out.println(mensaje.getSize()));
		
		/**
		 * Crea una lista de los mensajes que contienen una palabra.
		 */
		List<Mensaje> listaFiltradaSinLambda = new ArrayList<Mensaje>();
		for(Mensaje message : mensajes){
			if (message.getMessage().contains("existe")){
				listaFiltradaSinLambda.add(message);
			}
		}
		System.out.println(listaFiltradaSinLambda.size());
		
		List<Mensaje> listaFiltradaConLambda = 
				mensajes.stream().filter(message -> message.getMessage().contains("existe")).collect(Collectors.toList());
		
		System.out.println(listaFiltradaConLambda.size());
	}
}

Mensaje.java

package platzi;

public class Mensaje {
	private final int size;
	private final String message;
	
	public Mensaje(String message) {
		this.size = message.length();
		this.message = message;
	}
	
	public int getSize() {
		return size;
	}
	
	public String getMessage() {
		return message;
	}
}

build.gradle

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'application' // Para ejecutar 'gradle run' en consola

mainClassName = "platzi.LambdaExpressionMain"

Alexander Agrazal

student•

22 minutos innecesario para nuestro curso de Java APIs Rest. tomen nota Platzi.

Cesar David Ramírez Dimaté

student•

Otro título. Aprende lo básico de Java 8 si algún día tienes que toparte con él. Tranquilo, cualquier conocimiento recibido no lo puedes descartar y suponer que es innecesario.

Cesar David Ramírez Dimaté

student•

Java 8

Lambda Expressions
Streams
Date API
Programación Funcional (diferente a POO): Utilizar funciones como si fueran datos, poder anidarlas, etc.

Lambda Expressions:
Facilidad para enviar funciones como argumentos dentro de los métodos. Tratar nuestro código como si fueran datos.
En vez de enviar datos tipo primitivos u objetos como argumentos, se envían funciones. Esto se usaba en Java 7 con las clases anónimas, es una implementación de una interface como parámetro de un argumento. Para poder utilizar lambda expressions tiene que existir un concepto de interfaces funcionales.
Interfaces funcionales: Por lo menos debe tener un método abstracto. Un método abstracto es un método que se define (no tiene implementación) y se implementa con lambda.
Funciones como argumentos/código como datos