Hay que ver lo que nos calentamos la cabeza para llamar de otra forma los procesos repetitivos:
- bucles (for, while, do, if, ....)
- Iterators, colecciones ...
Ahora aparecen los Stream que no hay que confundir con los IOStream de java.
No voy a acosonsejar ni desaconsejar su uso, sino que me voy de "safari fotográfico" a conocer las nuevas especies que han entrado en el nicho ecológico de Java.
1. Ideas básicas
Parece ser que un stream es como el operador "|" (pipe) de los scripts de linux, donde la información se genera y se transforma, filtra etc y obtenemos algo.
1. El origen de los streams parece ser que es una colección, como por ejemplo un List<>.
2. Para trasformar una colección en un stream le aplicaremos el método stream.
3. Existen unos métodos que se aplican al stream que son de tipo eager que se ejecutan inmediatamente.
4. En cambio los métodos de tipo lazy no se ejecutan si tras ellos no llamos a un método eager.
5. Si un método devuelve un stream entonces es lazy.
6. Si un método devuelve un valor o nada (void), entonces es eager.
2. Operaciones básicas de los streams
collect(toList()) (Eager) Trasforma un stream en un List<>, si quisieramos transformarlo en un Set<> (que descarta los duplicados) sería collect(toSet()), y mas genericamente
List<String> collected =
Stream.of("a", "b", "c")
.collect(Collectors.toList());
y para comprobar que el resultado es correcto:
assertEquals(Arrays.asList("a", "b", "c"), collected);
y más genericamente podriamos hacer (de momento hablaremos mas adelante del operador ::")
stream.clollect(toCollection(TreeSet::new));
map() (Lazy) Trasforma un stream en otro, realizando una "transformación" de sus elementos
List<String> collected =
Stream.of("a", "b", "c")
.map(string -> string.toUpperCase())
.collect(Collectors.toList());
aquí convertimos a mayúscula los elementos y para comprobar que el resultado es correcto:
assertEquals(Arrays.asList("A", "B", "C"), collected);
filter() (Lazy) Filtramos los elementos de un stream que cumplen una condición.
List<String> collected =
Stream.of("a", "1a", "b", "c" ,"2c")
.filter(string -> isDigit(string.charAt(0)))
.collect(toList());
aquí solamente dejamos passar los que comienzan por un número y para comprobar que el resultado es correcto:
assertEquals(Arrays.asList("1a", "2c"), collected);
flatMap() (Lazy) Cambia un objeto por un stream y lo incluye en el stream final.
List<String> collected =
Stream.of(asList("a", "b"), asList("c", "d"))
.flatMap(strings -> strings.stream())
.collect(toList());
aquí solamente dejamos passar los que comienzan por un número y para comprobar que el resultado es correcto:
assertEquals(Arrays.asList("a", "b", "c", "d"), collected);
max() min() (Lazy) Obiene el máximo o mínimo en base a un comparador.
String masLarga =
Stream.of("a", "bc","d", "efg")
.max(Comparator.comparing(string -> strings.length()))
.get();
aquí recogemos la tira con longitud máxima y para comprobar que el resultado es correcto:
assertEquals("efg", masLarga);
reduce() (Eager) Obtiene un único resultado. Puede ser la generalizacion de los métodos count, min, max ..
int sumador =
Stream.of( 1, 2, 3, 4)
.reduce( 0, (suma, elemento) -> suma + elemento);
aquí recogemos la suma de los elementos y para comprobar que el resultado es correcto:
assertEquals(10, sumador);
4. Expresiones Lambda
Parece ser que una expresión Lambda es un tipo dado de un interface funcional, y en base a los cuales se puede inferir la función. O sea parecen 2 conceptos:
1. Interfaz funcional : Parece ser que en Java 8 se han definido 5 interfases funcionales que son
| Interfaz | Argumentos | Devuelve |
Ejemplo |
|---|
| Predicate<T> |
T |
boolean |
Si se cumple una condición |
| Consumer<T> |
T |
void |
imprimir un valor |
| Function<T,R> |
T |
R |
Obtener el nombre de un cliente |
| Supplier<T> |
Nada |
T |
Factory method |
| UnaryOperator<T> |
T |
T |
Logical not (!) |
| BinaryOperator<T,T> |
(T, T) |
T |
Multiplicar 2 números (*) |
Según
TutorialsPoint, hay bastante más.
2.Inferencia: En base a como se escribe, el compilador es capaz de inferir a que tipo de interfaz funcional nos estamos refiriendo.
También aparece el concepto de
Higher-Order Funtions, que es una función toma otra función como argumento o devuelve otra función. Cuando un interfaz funcional se utiliza como parámetro o como resuiltado, entonces hemos creado un función de Higher-Order (En adelante H-O). De hecho todas las funciones que se utilizan en el
Stream interfaz son de H-O.
Una de las ventajas de utilizar los Lambdas es que se hace mas clara la
declaración de lo que se quiere hacer.
Una cuestión a tener en cuenta es que las Lambda, solamente pueden acceder a variables externas que sean del tipo "
final" o sea que no admita cambios de valor, es decir es una constante. A pesar de las desventajas que tenga esto, tiene la ventaja que no tiene efectos colaterales respecto a las variables externas que utiliza ya que no puede modificarlas.
Veamos un ejemplo donde queremos crear una función que muestre por consola si se verifica una condición:
public void mostrar(Supplier<String> mensaje) {
if (isCondition()){
System.out.printl(mensaje.get());
}
}
Supongamos que este método forma parte de una clase llamada Chivato, que ademas tiene una función que construye un mensaje complejo llamada
constructorMensaje. Para llamarlo, como ya podemos utilizar funciones tipo
Supplier haríamos:
Chivato chivato = new Chivato();
chivato.mostrar (() -> "Mira esto:" + chivato.constructorMensaje());
5. Primitivas
Los
Streams trabajan con
objetos y no con primitivas. Si queremos trabajar con primitivas, tenemos dos opciones:
1.
Convertir las primitivas a objetos: Tiene la desventaja que los objetos consumen mas memoria que los primitivas
2. Utilizar
streams adaptados a primitivas.
En el segundo caso hay algunas clases y métodos que permiten trabajar con ellas. Veamos algunos de ellos:
mapToInt (): Extrae un valor entero de cada elemento de una colección de objetos. Devuelve un
IntStream.
summaryStatistics (): Obtiene una clase tipo
IntSummaryStatistics de un stream de primitivas tipo int.
IntSummaryStatistics (): Clase que guarda las estadísticas (max, min, promedio, suma, etc) de un stream de primitivas tipo int
Veamos un ejemplo
public static void mostrarEstaditicas (Personas personas) }
IntSummaryStatistic est =
personas.getEdades()
.mapToInt( persona -> persona.getEdad())
.summaryStatistics();
System.out.printf("Max: %d, MIn: %d: Ave: %f, Sum %d",
est.getMax(),
est.getMin(),
est.getAverage(),
est.getSum());
Análogamente existen otras clases y métodos para
LongStream y
DoubleStream.
6. Referencias a métodos
Mediante la referencia a métodos en las Lambda, se pueden hacer las siguientes equivalencias
Expresión Nueva
|
Expresión equivalente
|
Explicación
|
|---|
| Persona::getEdad |
persona.getEdad() |
Es de la forma Classname::methodName |
| Persona::new |
(nombre, edad) -> new Persona(nombre, edad) |
Constructor de la clase |
| String[]::new |
|
Creación de un array |
7. Las Null Pointer Exceptions y los Optional
La interfaz Optional se utiliza para aquellos casos que puede que el elemento no tenga un valor. Imaginemos una clase Persona que tenga de atributos nobre y teléfono. Hay personas como los niños que no tienen teléfono, por tanto este atributo se puede indicar con Otional:
public class Persona {
private String nombre;
private Optional<String> telefono
public Optional<String> getTelefono() {..}
}
Veamos que ventajas tenemos, al aparecer nuevos métodos:
orElse(): Ofrece valor alternativo si no existe el valor
String telf = persona.getTelefono().orElse("SIN TELEFONO");
orElseThrow(): lanza una excepción si no existe el valor
String telf = persona.getTelefono().orElseThrow(IllegalStatementException::new);
8. Otras utilidades de los streams
1. (maxBy, minBy) Obtener un objeto de entre una colección, que tenga un máximo (o mínimo). Supongamos la anterior clase Persona que tenga un atributo List<Personas> llamado hermanos, que sean los hermanos. Queremos obtener aquellas personas que tengan mayor número de hermanos. Podriamos hacerlo así
public Optional<Persona>masHermanos(Stream<Persona> personas) {
Function<Persona, Long> getNumHermanos = persona > persona.getHermanos().count();
return personas.collect(maxBy(comparing(getNumHermanos)));
}
igualmente existe minBy.
2.(
averagingInt)
Obtener el promedio de un valor de una colección.
public double promedioHermanos(List<Persona> personas) {
return personas.stream()
.collect(averagingInt(persona -> persona.getHermanos.size())));
}
3.(
partitioningBy)
Partir una colección en dos en base a un criterio. Supongamos que tenemos una función isHijoUnico que indica si la persona no tiene hermanos. Podemos obtener dos listas de personas, una sin hermanos y otra que tienen hermanos.
public Map<Boolean, List<Persona>> conYSinHermanos(Stream<Persona> personas) {
return personas.collect(partitioningBy(Persona::isHijoUnico));
}
4.(groupingBy) Agrupar varias coleccines en una sola. Supongamos que tenemos un campo en la persona que es la edad en años que es entero, y queremos agrupar todas las personas que tienen la misma edad.
public Map<int, List<Persona>> personasEdad(Stream<Persona> personas) {
return personas.collect(groupingBy(Persona::getEdad));
}
5.(joining) Agrupar los nombres de las personas en un string separdo por comas, y de corchetes en los extremos. Ejempo "[David, Juan, Enrique, Eduardo]"
String nombres=
personas.stream()
.map(Persona::getNombre)
.collect(Collectors.joining(", ", "[", "]"));
6.(
counting)
Obtener el numero de personas de una misma edad.
public Map<int, Long> personasEdad(Stream<Persona> personas) {
return personas.collect(groupingBy(Persona::getEdad, counting()));
