Introducci贸n a la programaci贸n Funcional

1

驴Qu茅 es la Programaci贸n Funcional?

Entendiendo las partes de la programaci贸n funcional

2

驴Qu茅 es una funci贸n en Java?

3

Funciones como ciudadanos de primera clase

4

Funciones puras

5

Entendiendo los efectos secundarios

6

Funciones de orden mayor

7

Funciones lambda

8

Inmutabilidad

Functional Programming en Java

9

Repositorio del curso

10

Configuraci贸n del entorno de trabajo

11

Revisando el paquete java.util.function: Function

12

Revisando el paquete java.util.function: Predicate

13

Revisando el paquete java.util.function: Consumer y Supplier

14

Revisando el paquete java.util.function: Operators y BiFunction

15

Entendiendo dos jugadores clave: SAM y FunctionalInterface

16

Operador de Referencia

17

Analizando la inferencia de tipos

18

Comprendiendo la sintaxis de las funciones lambda

19

Usando metodos default en nuestras interfaces

20

D谩ndole nombre a un viejo amigo: Chaining

21

Entendiendo la composici贸n de funciones

Optional y Streams: Datos mas interesantes

22

La clase Optional

23

Entendiendo los Streams

24

驴Qu茅 son los Stream listeners?

25

Operaciones y Collectors

26

Streams de tipo espec铆fico y Paralelismo

27

Operaciones Terminales

28

Operaciones Intermedias

29

Collectors

Todo junto: Proyecto Job-search

30

job-search: Un proyecto para encontrar trabajo

31

Vista r谩pida a un proyecto de Gradle

32

Revisando las opciones para nuestro CLI

33

Librer铆as adicionales para nuestro proyecto

34

Entendiendo la API de jobs

35

Dise帽ando las Funciones Constructoras de nuestro Proyecto

36

Agregando validaciones de datos

37

Dise帽ando las funciones de transformacion de datos

38

Creando flujos extras de transformaci贸n de Datos

Conclusiones

39

Un repaso a lo aprendido

A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Revisando el paquete java.util.function: Predicate

12/39
Recursos

Aportes 44

Preguntas 7

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

Para activar ese estilo de fuentes con IntelliJ puedes hacerlo de la siguiente forma

Settings 鈫 Editor 鈫 Font Seleccionar la fuente fira code

Podemos utilizar Predicate para validar la existencia de stock de productos.

Uff!!! es algo nuevo totalmente para mi, yo vengo de programacion orientada a objetos y he visto y programado en javascript donde he visto las funciones anonimas, y es por eso eque no me he perdido tanto, pero sin duda es otro paradigma de programacion, pero se decir q el curso esta muy intersante

Para el curioso:

Son ligaduras.

FiraCode es una fuente Open-Source que las posee.

Predicate: recibe un dato y devuelve un boolean. Se invoca con test() Predicated <integer> ispar = x -> x % 2 == 0; ispar.test(5) //false ispar.test(6) // true

Un Predicado es un interface funcional que define una condici贸n que un objeto determinado debe cumplir.

dios mio que f谩cil amo la programaci贸n funcional, la programacion funcional ser谩 mi nuevo pastor

Si alguien se pregunta como se ejecuta la funci贸n isOdd es con apply tambien.

Function<Integer, Boolean> isOdd = x -> x % 2 == 0;

        System.out.println(isOdd.apply(5));
package ejemploLambdas;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;


public class Main {

    static List<Persona> filtrar(List<Persona> personas, Predicate<Persona> predicado){
        List<Persona> resultado = new ArrayList<Persona>();
        for (Persona p: personas){
            if(predicado.test(p)){
                resultado.add(p);
            }

        }
        return resultado;

    }

    public static void main(String[] args) {

        List<Persona> listaPersonas = new ArrayList<Persona>();
        listaPersonas.add(new Persona("Laura ", 17));
        listaPersonas.add(new Persona("Marina ", 32));
        listaPersonas.add(new Persona("Edgar ", 27));
        listaPersonas.add(new Persona("Claudia ", 28));
        listaPersonas.add(new Persona("Luciana ", 18));
        listaPersonas.add(new Persona("Angie ", 35));

        ///CREAMOS DOS VARIABLES DE TIPO predicado para que busque mayor a 18 a帽os y que el nombre empiece por L
        Predicate<Persona> predMayorEdad = (persona)->persona.getEdad()>= 18;
        Predicate<Persona> predNombreL = (persona)->persona.getNombre().startsWith("L");


        List<Persona> personaAdulta = filtrar(listaPersonas, predMayorEdad.and(predNombreL));
        System.out.println("Listado de personas adultas cuyo nombre empueza por L ");
        for(Persona p: personaAdulta){
            System.out.println(p);
        }
    }
}

Est谩s clases van volando

Para los que se pregunten como hace para tener los () y los {} de distintos colores (el { de mas afuera tiene el mismo color que el } de mas afuera y asi sucesivamente) es un plugin que se llama Rainbow Brackets. Lo pueden encontrar en File > Settings > Plugins y ahi buscan Rainbow Brackets

Me est谩 costando asimilar todo esto de la programaci贸n funcional. Soy el 煤nico ?

Que plugin o complemento usas en Intellij para que te aparezca las flechas completas?

Se me ocurre que a trav茅s de la programaci贸n funcional, podr铆a generar reportes de una forma mas r谩pida, es decir envi贸 un array, hago validaciones y a partir de eso genero un nuevo array con la data que necesito.

Muy practica forma de realizar validaciones de manera intuitiva y f谩cil de comprender, este paradigma me esta haciendo volar la imaginaci贸n con todas las posibilidades de sus implementaciones.

Una funci贸n usando un predicado 馃槂

Predicate<Student> pasa = student -> student.getCalif() >= 6.0;
        Function<Student,String> textoPasa = estudiante -> pasa.test(estudiante)?"Aprobado":"Reprobado";

        Student student = new Student("Juan",5.9);
        System.out.printf( "\nel estudiante (%s): " + textoPasa.apply(student), student.getNombre());
        Student student1 = new Student("Pancho",6.0);
        System.out.printf( "\nel estudiante (%s): " + textoPasa.apply(student1), student1.getNombre()); 

Si necesitan una definicion para sus apuntes un predicate es una interface funcional que define una condicion que el objeto determinado debe cumplir. Predicate dispone de un metodo llamado test que recibe el objeto y comprueba si se cumple dicha condicion.

Ahora entiendo un poco mas de que se trata la programaci贸n funcional.

**DE MANERA RESUMIDA **

Las ligaduras (la flecha y el igual grandote) tienen la siguiente notaci贸n: !=, ->, ==, <-|, /\, =~ ... etc. Si la fuente que emplean tiene su representaci贸n gr谩fica, aqu铆 es donde se activa: File / Settings / Color scheme / Color scheme font 鈽戯笍 Use color scheme font instead of the default 鈽戯笍 Enable font ligatures

Java nos permite crear funciones de una forma simple y sencilla, como esta:

Function<Integer, Boolean> isOdd = x => x % 2 ==1

Wow! (O.O)

Excelente muchas gracias

Muy buena clase, programar para cosas muy especificas

Los he utilizado para filtrar tablas por diferentes condiciones.
Esta es una parte del codigo:

	private void establecerCriterioActividad(String newValue) {
		// TODO Auto-generated method stub
if(filtroBuscadorActividad.getValue().equalsIgnoreCase("Hora")) {
				filteredListActividad.setPredicate( actividad -> newValue == null || newValue.isEmpty() || actividad.getHoraString().toLowerCase()
		                .contains(newValue.toLowerCase()));
		}else if(filtroBuscadorActividad.getValue().equalsIgnoreCase("Accion")) {
			filteredListActividad.setPredicate( actividad -> newValue == null || newValue.isEmpty() || actividad.getTipo_accion().toLowerCase()
	                .contains(newValue.toLowerCase()));
		}else if(filtroBuscadorActividad.getValue().equalsIgnoreCase("Tabla")){
			filteredListActividad.setPredicate( actividad -> newValue == null || newValue.isEmpty() || actividad.getTabla_afectada().toLowerCase()
	                .contains(newValue.toLowerCase()));
		}else if(filtroBuscadorActividad.getValue().equalsIgnoreCase("Columna")){
			filteredListActividad.setPredicate( actividad -> newValue == null || newValue.isEmpty() || actividad.getColumna_afectada().toLowerCase()
	                .contains(newValue.toLowerCase()));
		}else if(filtroBuscadorActividad.getValue().equalsIgnoreCase("Identificador campo")){
			filteredListActividad.setPredicate( actividad -> newValue == null || newValue.isEmpty() || 			   String.valueOf(actividad.getRow_id()).toLowerCase()
	                .contains(newValue.toLowerCase()));
		}
	} 

Este curso va genial, viniendo de Javascript me siento muy familiarizado con este paradigma y Java esta empezando a dejar de ser ese lenguaje que tenia que aprender obligatoriamente para mi empresa para volverse un lenguaje cool y sexy 馃槒.

Para los que venimos de Javascript . Podemos ver que las mencionada lambdas son arrow functions. , es un viejo conocido ya que se usa mucho este tipo de programacion en Javascript. Es hermoso saber esto en Java de verdad :33

Interfaz-> Predicate : Funcion que trabaja sobre un tipo y genera un Boolean.
Predicate鈥

Waoo, superpoderes.

Excelente clase

public class PruebaFunction {

    //Plugin para dar color a las llaves
    //https://plugins.jetbrains.com/plugin/10080-rainbow-brackets

    //Para activar una fuente difrente (Fira code)
    //Settings  --> Editor  --> Font --> Fira code
    //Seleccionar: Enable font ligatures


    //Utilizar atajo psvm
    public static void main(String[] args) {

        //utilizar atajo sout
        System.out.println("Hola platzi !!");

        //Una funci贸n idealmente -> Recibe un tipo de dato y genera un resultado o retorna un valor
        //En este caso recibe un entero y retorna un entero
        Function<Integer, Integer> squareFunction =
                new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer x) {
                return x*x;
            }
        };

        // Invocar una funci贸n --> se invoca al m茅todo apply
        System.out.println(squareFunction.apply( 5));
        System.out.println(squareFunction.apply(25));

        //M茅todo normal -> es lo mismo
        //La diferencia es que las fucciones tambi茅n son tipos -> y al ser tipos podemos involucrarles en variables,
        // pasarlas como parpametros o recibirlas como retornos de una ejecuci贸n
        System.out.println("M茅todo normal: " + square(5));


        //Nueva sintaxis que permite definir funciones de forma m谩s simple y que sea m谩s legible
        //Recibe un entero y devuelve un booleano (Definir si el n煤mero es impar --> Tonamos x, sacamos el m贸dulo de 2 y revisamos si el m贸dulo es 1
        //Esta versi贸n es m谩s corta y legible
        Function<Integer, Boolean> isOdd = x -> x%2 == 1;

        //Predicate
        //Es una especie de funci贸n que trabaja sobre un tipo pero genera un boolean--> Lo  que hace es testear si algo es v谩lido
        Predicate<Integer> isEven = x -> x%2 == 0;
        //para poder ejecutar este tipo de funviones especificas conocidas como predicados, hay que invocarlos con un
        // m茅todo diferente al apply, en este caso test()
        isEven.test(4); //true


        //Evaluar la calificaci贸n de un estudiante
        Predicate<Integer> evaluar = x-> x >= 7;

        Student cggm = new Student(7);
        System.out.println("Evaluar estudiante cggm: " + evaluar.test(cggm.getCalificacion()));

        Student estudiante1 = new Student(6);
        System.out.println("Evaluar estudiante estudiante1: " + evaluar.test(estudiante1.getCalificacion()));



    }

    static class Student{
        private int calificacion;

        public Student(int calificacion) {
            this.calificacion = calificacion;
        }

        public int getCalificacion() {
            return calificacion;
        }
    }

    //M茅todo normal
    static int square (Integer x){
        return x*x;
    }

    //
}

Excelente clase

fucntion.apply(x);

Muchas gracias instructor Sinuh茅, no conoc铆a esa forma de establecer las funciones que nos retornan booleanos a trav茅s del Predicate, me ser谩n muy 煤tiles al momento de verificar datos y hacer pruebas r谩pidas.

Se podr铆a tener un clase utilitaria que use la interfaz Predicate para definir validaciones transversales en nuestro proyecto.

Genial, hay muchas cosas por aprender.

Muchas gracias 馃槂 aprendiendo nuevas funcionalidades de Java 8 馃槂

excelente鈥 no conoc铆a lo de predicado

Maravilloso! Esto es genial! Y el profesor es muy bueno!
Esto le dan un dinamismo y poder a Java alucinante!

Esta fabuloso este curso

Si yo quisiera crear un predicado o una funci贸n para que reciba 2 o mas 鈥減ar谩metros鈥 deber铆a decir en el tipo de dato si es un array o una lista, esto es una buena practica, es recomendable, o las funciones y los predicados son para manipular un 煤nico dato?

package com.platzi.functional._04_functional;

import java.util.function.Function;
import java.util.function.Predicate;

public class MathFunctions {
    public static void main(String[] args) {

        Function<Integer, Integer> squareFunction = new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer number) {
                return number * number;
            }
        };
        //Nueva sintaxis para funciones
        Function<Integer, Boolean> isOdd = x -> x % 2 == 1;

        /* Es una funcion que trabaja sobre un tipo y genera un boolean
         Lo que hace es testear que algo sea verdadero o falso*/
        Predicate<Integer> isEven = x -> x % 2 == 0;
        isEven.test(5);
        isEven.test(4);

        System.out.println(square(2));

        Predicate<Student> isApproved = student -> student.calificacion > 6.0;

        Student alejandro = new Student(5.0);
        System.out.println("Student aprroved: " + isApproved.test(alejandro));

    }
    static int square(int x){
        return x * x;
    }
    static class Student{
        private double calificacion;

        public Student(double calificacion) {
            this.calificacion = calificacion;
        }

        public double getCalificacion() {
            return calificacion;
        }
    }
}

vengo haciendo la ruta de Java saltandome algunas partes que considero no esenciales (por motivos que no vale la pena traer) y este curso me esta encantando, se nota que a Sinuhe a veces le cuesta mantener la fluidez frente a la camara pero mantiene una simplicidad asombrosa al explicar temas que siempre supuse complicados cuando los escuchaba mencionar por otros profesores (como en C# donde si hice la ruta completa), mis mas sinceras felicitaciones a Sinuhe aunque claramente si estoy ac谩 entendiendo esto tambi茅n es gracias a los profesores de las otras rutas y cursos

wow, se me est谩 facilitando mucho