www.devcode.la
www.devcode.la
www.devcode.la
www.devcode.la
www.devcode.la
Permiten representar operaciones de forma simple.
Dependen de las nuevas interfaces funcionales.
La sintaxis incluye referencias de método y constructor.
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.
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();
}
};
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;
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");
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
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.
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]
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
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));
www.devcode.la
Paralelización
List<String> words = readWords();
words
.parallelStream()
.filter(w -> w.length() > 12)
.collect(Collectors.toList());
www.devcode.la
Documentación Oracle: https://goo.gl/fHZ2K8