Explicacion de operaciones y collectors

- Also: corregido 'devuelve' -> 'retorna' en los comentarios

Author: sierisimo

modules/src/main/java/com/platzi/functional/_04_functional/_01_FunctionDemo.java

@@ -33,7 +33,7 @@ public RESULT apply(TYPE t) {
 
 
     /**
-     * Veamos un ejemplo simple… una funcion que nos devuelve si un numero es par
+     * Veamos un ejemplo simple… una funcion que nos retorna si un numero es par
      */
     private static void functionExample() {
         Function<Integer, Boolean> isEven = new Function<Integer, Boolean>() {

modules/src/main/java/com/platzi/functional/_04_functional/_04_OperatorsAndBiFunctions.java

@@ -13,7 +13,7 @@ public class _04_OperatorsAndBiFunctions {
     private static void unaries() {
         //Aunque esta funcion luce muy parecida a una que ya usamos previamente,
         //el tenerla como UnaryOperator nos deja en claro que es una operacion que
-        //trabaja sobre un tipo y nos devuelve el mismo tipo.
+        //trabaja sobre un tipo y nos retorna el mismo tipo.
         UnaryOperator<Integer> square = x -> x * x;
 
         UnaryOperator<String> quote = s -> "\"" + s + "\"";

modules/src/main/java/com/platzi/functional/_06_reference_operator/_01_Operator.java

@@ -138,7 +138,7 @@ private void weirdStuff() {
         //con la definicion de la funcion que necesitamos:
 
         /*
-        La clase tiene definido este metodo que recibe un string y devuelve un int.
+        La clase tiene definido este metodo que recibe un string y retorna un int.
 
 
         class HelperOperator {
@@ -147,7 +147,7 @@ public int sayNameAge(String s){…}
         }
 
 
-        La funcion que tenemos que pasar, justamente, recibe un string y devuelve un int…
+        La funcion que tenemos que pasar, justamente, recibe un string y retorna un int…
 
         giveMeAFunction(Function<String, Integer> function)
 

modules/src/main/java/com/platzi/functional/_12_currying/Currying.java

@@ -5,7 +5,7 @@
 public class Currying {
     /**
      * Empecemos con algo que ya conocemos: una FunctionalInterface que toma 3 tipos de datos
-     * F, S, T y devuelve un tipo de dato R cuando se manda a llamar su metodo apply.
+     * F, S, T y retorna un tipo de dato R cuando se manda a llamar su metodo apply.
      * <p>
      * Hasta que no deberia haber nada nuevo.
      */

modules/src/main/java/com/platzi/functional/_14_optionals/Optionals.java

@@ -182,7 +182,7 @@ static Optional<String> conOptional(List<String> names) {
      * Funcion usando ambos casos:
      */
     static void outside() {
-        //Invocando a un metodo que no sabemos que devuelve:
+        //Invocando a un metodo que no sabemos que retorna:
         String directResult = antesDeOptional(null);
         if (directResult != null) {
             directResult = directResult.replace("Sierisimo", "Sinuhe");

modules/src/main/java/com/platzi/functional/_16_listeners/StreamListeners.java

@@ -52,22 +52,22 @@ static void listeners() {
             cosas en paralelo.
          */
         Stream<List<String>> coursesModules = Stream.of(/*Obentemos los cursos de una DB*/);
-        //Nos devuelve un Stream de List<String> donde las listas tienen literalmente el elemento "Java"
+        //Nos retorna un Stream de List<String> donde las listas tienen literalmente el elemento "Java"
         //Tal vez nuestra busqueda era sobre cursos que contuvieran la palabra Java como parte del nombre…
         coursesModules.filter(s -> s.contains("Java"));
 
         /*
         Para poder operar este tipo de streams, usaremos una operacion llamada flatMap
 
-        flatMap toma un Stream<Collecion<T>> y nos devuelve un Stream<T>.
+        flatMap toma un Stream<Collecion<T>> y nos retorna un Stream<T>.
 
         Es decir, flatMap se encarga de combianr todos los elementos de las colecciones de los streams
         en un solo Stream. Para hacer esto, debemos proveer una lambda que emita un stream como resultado
 
         Si nuestro Stream inicial tenia:
         Stream{ List{ "Node.js", "JavaScript"}, List{"Android", "Kotlin"}, List{"JavaSE 8", "Java FP"}}
 
-        Aplicar flatMap devuelve:
+        Aplicar flatMap retorna:
         Stream{ "Node.js", "JavaScript", "Android", "Kotlin", "JavaSE 8", "Java FP" }
          */
         List<String> nodeCourses = Utils.getListOf("Node.js", "Express.js", "Eventloop");

modules/src/main/java/com/platzi/functional/_17_operators_collectors/Operators.java

@@ -0,0 +1,166 @@
+package com.platzi.functional._17_operators_collectors;
+
+import com.platzi.functional.util.Utils;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Operators {
+    static void operadores() {
+        /*
+        Hasta ahora hemos usado lambdas indiscriminadamente en nuestros streams sin revisar o validar
+        el estado del stream. Es decir, si ejecutas algunos ejemplos anteriores puede que te encuentres con
+        algunas excepciones no explicadas. Este es el tema donde explicaremos que diferencia hay entre usar
+
+        forEach vs map por ejemplo.
+         */
+
+        /*
+        En nuestros streams, generalmente nos encontramos con elementos y realizamos operaciones sobre ellos.
+         */
+        Stream<Integer> numbers = Utils.getListOf(1, 2, 3, 4).stream();
+        numbers.map(i -> i * 2);
+
+        /*
+        Sin embargo, ciertas operaciones nos retornan un resultado, por ejemplo, map genera un nuevo
+        Stream<V> partiendo de un Stream<T>. Es decir, cada que realizamos una operacion `map` en un stream
+        lo que hace en realidad es generar un nuevo Stream, donde a cada elemento se le ira aplicando
+        la operacion que nosotros definimos.
+
+        Esto puede ser representado:
+         */
+        Stream<Integer> numbersV2 = Utils.getListOf(1, 2, 3, 4).stream();
+        Stream<Integer> numbresBy2 = numbersV2.map(i -> i * 2);
+
+        /*
+        Mas importante aun es entender que una vez aplicado un operador sobre un stream este stream no puede ser
+        usado de nuevo:
+         */
+        Stream<Integer> squares = numbersV2.map(i -> i * i); //Genera un IllegalStateException.
+        //Lo cual representa una pequeña limitante sobre el uso de streams.
+
+        /*
+        Hay metodos que modifican los datos de nuestro stream y metodos que nos dejan obtener un resultado de
+        la iteracion de los elementos del stream. En ambos casos se les conoce como Operations
+
+        Es importante identificar que muchos de estos retornan un nuevo Stream. Tras realizar una operacion
+        sobre un stream, el dato que existe en el stream puede cambiar, aqui un ejemplo:
+         */
+        Stream<String> courses = Stream.of(
+                "Java:Introductorio",
+                "Python:Introductorio",
+                "Machine Learning:Avanzado",
+                "JavaScript:Introductorio",
+                "Node.js:Intermedio",
+                "Android:Intermedio",
+                "iOS:Intermedio"
+        );
+
+        Stream<String> introductoryCourses = courses.filter(course -> course.contains("Introductorio"));
+
+        Stream<String[]> partsNames = introductoryCourses.map(course -> course.split(":"));
+
+        Stream<String[]> partsWithData = partsNames.filter(parts -> parts.length > 1);
+
+        Stream<String> justNamesStream = partsWithData.map(courseData -> courseData[0]);
+
+        Stream<String> justActualNamesPresent = justNamesStream.filter(name -> !name.isEmpty());
+
+        /*
+        O en una version con chaining:
+
+        Stream<String> justNamesStream = courses.filter(c -> c.contains("Introductorio"))
+                .map(c -> c.split(":"))
+                .filter(parts -> parts.length > 1)
+                .map(courseData -> courseData[0])
+                .map(c -> c[0])
+                .filter(name -> !name.isEmpty());
+         */
+
+        /*
+        Existen operaciones que nos permite obtener un resultado final despues de operar sobre los elementos de un stream.
+
+        Cuando obtenemos un resultado final de la iteracion de un stream, se dice que se invoco una Operacion Final.
+
+        Es importante entender que aunque tengamos multiples operaciones sobre un Stream, el Stream no sera iterado
+        hasta no agregar una operacion final. Esto es benefico pues podemos ir pasando el Stream por diferentes metodos/funciones
+        hasta que sea necesario obtener el valor resultante.
+         */
+        Stream<List<String>> coursesStream = getCourses();
+        Stream<String> courseDataStream = flatMapCourses(coursesStream);
+        Stream<String[]> partsStream = splitInformation(courseDataStream);
+        Stream<String[]> filteredPartsStream = filterAdvanceCourses(partsStream);
+        Stream<String> advanceCourseNamesStream = getNamesStream(filteredPartsStream);
+
+        /*
+        hasta este punto, no se ha procesado ningun stream a pesar de las llamadas a metodos.
+        Esto es porque no se ha agregado una operacion final que desencadene la iteracion en el
+        ningun stream.
+
+        Agregar una operacion final es tan sencillo como agregar una operacion no final:
+         */
+        //long totalAdvanceCourses = advanceCourseNamesStream.count();
+
+        /*
+          Es hasta este punto que los datos se empiezan a iterar para obtener un resultado.
+          Sabemos que `count()` es una operacion final porque no retorna un Stream, retorna un
+          resultado de aplicar la operacion correspondiente.
+
+          En muchas ocasiones lo mas comun es encontrarte con una operacion de recoleccion de datos
+          utilizando una de las implementaciones de Collector.
+
+          Esta es la manera ideal de convertir un Stream a una coleccion (Set, Map, List, Collection)
+          o convertir todos los datos de un Stream a un tipo en concreto (por ejemplo, concatenar todos los elementos)
+         */
+        List<String> advanceCourseNamesList = advanceCourseNamesStream.collect(Collectors.toList());
+        
+//
+//
+//
+//
+
+        /*
+        El ejemplo anterior representa algo sucediendo entre multiples partes de un proyecto,
+        una que procese el dato de una peticion web, otro que lo almacene en una base de datos
+        otro que haga conversion de datos… etc.
+         */
+    }
+
+    //
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+    static Stream<List<String>> getCourses() {
+        List<String> nodeCourses = Utils.getListOf("Node.js:Intermedio", "Express.js:Intermedio", "Eventloop:Avanzado");
+        List<String> javaCourses = Utils.getListOf("Spring:Introductorio", "Maven:Intermedio", "Gradle:Avanzado", "Funtional:Introductorio");
+
+        return Stream.of(nodeCourses, javaCourses);
+    }
+
+    static Stream<String> flatMapCourses(Stream<List<String>> courses) {
+        return courses.flatMap(Collection::stream);
+    }
+
+    static Stream<String[]> splitInformation(Stream<String> coursesData) {
+        return coursesData.map(courseData -> courseData.split(":"));
+    }
+
+    static Stream<String[]> filterAdvanceCourses(Stream<String[]> courses) {
+        return courses.filter(data -> data.length > 1)
+                .filter(data -> data[1] == "Avanzado");
+    }
+
+    static Stream<String> getNamesStream(Stream<String[]> coursesData) {
+        return coursesData.map(courseData -> courseData[0]);
+    }
+}