Programación Funcional en Java: Uso de Streams y Operaciones Terminales

He seguido con atención los cursos de Backend en Java y hasta ahora no he visto nada de Generics (lo que sé de Generics lo aprendí por cuenta). En este curso se utiliza mucho ejemplos con generics. El curso de Avanzado de Java SE debe tocar de formas mas profunda Java Collections y Generics.

Intermediate Operations:

1. map: The map method is used to returns a stream consisting of the results of applying the given function to the elements of this stream.
   List number = Arrays.asList(2,3,4,5); List square = number.stream().map(x->x*x).collect(Collectors.toList());

2. filter: The filter method is used to select elements as per the Predicate passed as argument.
   List names = Arrays.asList("Reflection","Collection","Stream"); List result = names.stream().filter(s->s.startsWith("S")).collect(Collectors.toList());

3. sorted: The sorted method is used to sort the stream.
   List names = Arrays.asList("Reflection","Collection","Stream"); List result = names.stream().sorted().collect(Collectors.toList());

Terminal Operations:

1. collect: The collect method is used to return the result of the intermediate operations performed on the stream.
   List number = Arrays.asList(2,3,4,5,3); Set square = number.stream().map(x->x*x).collect(Collectors.toSet());

2. forEach: The forEach method is used to iterate through every element of the stream.
   List number = Arrays.asList(2,3,4,5); number.stream().map(x->x*x).forEach(y->System.out.println(y));

3. reduce: The reduce method is used to reduce the elements of a stream to a single value.
   The reduce method takes a BinaryOperator as a parameter.
   List number = Arrays.asList(2,3,4,5); int even = number.stream().filter(x->x%2==0).reduce(0,(ans,i)-> ans+i);

siempre sera una operacion final cuando retorna algo que no sea otro stream, si retrona un stream sera una operacion intermedia

Ejemplo básico del uso de peek:

List<String> stringList = UtilsName.getList("123456", "1", "12", "1234", "555");

stringList.stream()
        .peek(number -> System.out.println("Dato: " + number))
        .filter(number -> number.contains("34"))
        .peek(number -> System.out.println(" - Este dato contiene 34"))
        .map(number -> " - Contenido adicional para el Print del Foreach " + number)
        .forEach(System.out::println);

Dato: 123456
 - Este dato contiene 34
 - Contenido adicional para el Print del Foreach 123456
Dato: 1
Dato: 12
Dato: 1234
 - Este dato contiene 34
 - Contenido adicional para el Print del Foreach 1234
Dato: 555

OK entonces los Stream no parecen tan utiles si en cada operacion ten emos que generar un nuevo tipo de variable, esto haria que el codigo sea muuy feo, Pero lo vimos en el modulo anterior... CHEINING. ES NUESTRA SOLUCION

Operacion final si te regresa algo o no, si te regresa un string es una operaciones intermedia

Estupenda clase instructor Sinuhé, por medio del uso chaining se puede aprovechar mucho más los streams.

void es un dato final

“Una vez consumido un Stream ya no puede volver a utilizarse”

Los Stream permiten realizar operaciones en los datos de manera más concisa y eficiente en comparación con los enfoques tradicionales que implican bucles explícitos. Puedes realizar operaciones como filtrado, transformación, agrupación y reducción utilizando métodos de Stream.

En Java, Stream es una característica que se introdujo en Java 8 como parte del paquete java.util.stream. Un Stream es una secuencia de elementos que se puede procesar de manera funcional. Proporciona una forma más elegante y declarativa de realizar operaciones en colecciones de datos, como listas, conjuntos y mapas.

✅

Genial.

Super 😃