Curso de

Java 8: lambdas y streams

www.devcode.la

www.devcode.la

INSTRUCTOR

• Enrique Munguía
• Software Engineer @Google
• Twitter: @enrique7mc_
• Blog: enrique7mc.com

www.devcode.la

OBJETIVOS

• Aprender y aplicar algunas de las características más importantes de Java 8:
  • Expresiones lambda
  • Interfaces funcionales
  • API de Streams

REQUISITOS

• Conceptos básicos de Java

• Experiencia usando un IDE

www.devcode.la

Recomendado: IntelliJ Idea Community

Expresiones lambda

Novedades en Java 8

www.devcode.la

Permiten representar operaciones de forma simple.

Dependen de las nuevas interfaces funcionales.

La sintaxis incluye referencias de método y constructor.

API de Streams

Novedades en Java 8

www.devcode.la

Hacen más simple la manipulación de colecciones.

Especifican "cuál" es el resultado en lugar de "cómo" obtenerlo.

Incluye soporte para paralelización de operaciones.

Expresiones Lambda

www.devcode.la

Una expresión lambda es un bloque de código que puede incluir argumentos.

(ActionEvent e) -> System.out.println(e.getTarget())

(first, second) -> Integer.compare(first.length(), second.length());

() -> { 
  for (int i = 0; i < 10; i++) { 
    doWork();
  }
};

Expresiones Lambda

www.devcode.la

Sintaxis

// Sin argumentos
() -> { 
  for (int i = 0; i < 10; i++) { 
    doWork();
  }
};
() -> doWork();


// Un argumento
(String name) -> System.out.println(name);
(name) -> System.out.println(name);
name -> System.out.println(name);

// Múltiples argumentos
(int a, int b) -> {
  return a + b;
}
(int a, int b) -> a + b;
(a, b) -> a + b;

Expresiones Lambda

www.devcode.la

Interfaces funcionales

// Ejemplo Predicate
Predicate<String> stringLen  = (s) -> s.length() < 10;

// Ejemplo Consumer
Consumer<String> consumerStr = (s) -> System.out.println(s.toLowerCase());

// Ejemplo Function
Function<Integer,String> converter = (num) -> Integer.toString(num);

// Ejemplo Supplier
Supplier<String> s  = () -> "Java 8";

// Ejemplo Binary Operator
BinaryOperator<Integer> add = (a, b) -> a + b;

// Ejemplo Unary Operator
UnaryOperator<String> str  = (msg)-> msg.toUpperCase();

// Ejemplo Functional Interface
Action action = () -> System.out.println("Inside an action");

Expresiones Lambda

www.devcode.la

Referencias de método

// Referencia a un método estático
ContainingClass::staticMethodName

// Referencia al método de instancia de un objeto
containingObject::instanceMethodName

// Reference al método de instancia de un tipo en particular
ContainingType::methodName

// Referencia de constructor
ClassName::new

API de Streams

www.devcode.la

Los Streams permiten procesar colecciones de manera eficiente.

Se pueden crear a partir de colecciones, arreglos e iteradores.

Incluyen una gran variedad de métodos para ejecutar las operaciones más comunes.

API de Streams: transformaciones

www.devcode.la

El método filter permite incluir solo ciertos elementos

// ["hello", "java", "streams"]
words.filter(w -> w.length() > 5)
// ["streams"]

El método map permite transformar elementos

// ["hello", "world"]
words.map(String::toUppercase)
// ["HELLO", "WORLD"]

www.devcode.la

El método limit modifica el número de elementos

// [1, 2, 5, 6, 7, 9, 10]
numbers.limit(3)
// [1, 2, 5]

El método distinct remueve duplicados

// [1, 1, 2, 3, 3, 3]
numbers.distinct()
// [1, 2, 3]

El método sorted ordena los elementos

// [4, 2, 1, 3]
numbers.sorted()
// [1, 2, 3, 4]

API de Streams: transformaciones

API de Streams: operaciones terminales

www.devcode.la

El método count regresa el número de elementos

// [1, 2, 5, 6, 7, 9, 10]
numbers.count();
// 7

El método max regresa el mayor elemento

// [1, 0, 5, 3, 9, 3]
numbers.max();
// 9

El método min regresa el menor elemento

// [1, 0, 5, 3, 9, 3]
numbers.min();
// 0

API de Streams: colectar elementos

www.devcode.la

Colectar a una lista

// [1, 2, 5, 6, 7, 9, 10]
numbers.collect(Collectors.toList);

Colectar a un set

// [1, 0, 5, 3, 9, 3]
numbers.collect(Collectors.toSet());
numbers.collect(Collectors.toCollection(TreeSet::new));

Colectar a un mapa

 Map<Integer, String> idToName =
        people.collect(toMap(Person::getId, Person::getName));

API de Streams

www.devcode.la

Paralelización

List<String> words = readWords();
words
  .parallelStream()
  .filter(w -> w.length() > 12)
  .collect(Collectors.toList());

Conclusiones

www.devcode.la

• Aprendimos la sintaxis y utilidad de las expresiones lambda.

• Usamos una variedad de métodos de la API Stream.

• Creamos ejemplos que pueden ser útiles en la construcción de sistemas más complejos.

Documentación Oracle: https://goo.gl/fHZ2K8