Skip to content

Instantly share code, notes, and snippets.

@abdorah

abdorah/JavaFunctionalProgramming.md

Last active March 1, 2023 05:47
Download ZIP

Revisions

  1. abdorah renamed this gist Dec 10, 2020. 1 changed file with 0 additions and 0 deletions.
    0 .md → JavaFunctionalProgramming.md
    View file
    File renamed without changes.
  2. abdorah revised this gist Dec 10, 2020. 1 changed file with 1 addition and 1 deletion.
    2 changes: 1 addition & 1 deletion .md
    View file
    Original file line number Diff line number Diff line change
    @@ -28,7 +28,7 @@ To understand exactly why I choose to follow this planing You need to understand

    ## 1) Java 8 Stream API

    Java 8 Stream is a sequence of elements from certain source, on which we can perform basic aggregate operations. This source can be a collection, array or a stream - this is called *pip-lining*. In contrast to collections, streams aren't data structure. They allow to extract the required value only when we need it. Also they support lazy evaluation and were initially created to be used with lambdas(refer to the second part). They are contained under the package java.util.stream. There is a very large set of operations to perform on a stream. The majority of them return a stream so that we can perform more operations. Moreover streams don't store data nor changes. They just perform iteration internally once and then return a result. So we say that they are **consumable and functional in nature**. On more powerful point for stream is that they are possibly unbounded. Thus, you can perform operations on the first and last elements of a stream with no worries for its size or the order of elements because they also keep the same order of elements as the source.
    Java 8 Stream is a sequence of elements from certain source, on which we can perform basic aggregate operations. This source can be a collection, array or a stream - this is called *pip-lining*. In contrast to collections, streams aren't data structure. They allow to extract the required value only when we need it. Also they support lazy evaluation and were initially created to be used with lambdas(refer to the second part). They are contained under the package java.util.stream. There is a very large set of operations to perform on a stream. The majority of them return a stream so that we can perform more operations. Moreover streams don't store data nor changes. They just perform iteration internally once and then return a result. So we say that they are **consumable and functional in nature**. One more powerful point for stream is that they are possibly unbounded (unlimited, so we don't have to precis a certain size for a stream). Thus, you can perform operations on the first and last elements of a stream with no worries for its size or the order of elements because they also keep the same order of elements as the source.

    *This article will just give some important and highly used examples of functions and operations. If you were looking for more operations that java offers, you can look for them [here](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html).*

  3. abdorah revised this gist Dec 6, 2020. 1 changed file with 6 additions and 0 deletions.
    6 changes: 6 additions & 0 deletions .md
    View file
    Original file line number Diff line number Diff line change
    @@ -262,3 +262,9 @@ Thank you for reading.
    ### References
    [HowToDoInJava](https://howtodoinjava.com/java-8-tutorial/)
    Oracle Documentation:
    [Function](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html)
    [Stream](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html)
  4. abdorah revised this gist Dec 6, 2020. 1 changed file with 36 additions and 30 deletions.
    66 changes: 36 additions & 30 deletions .md
    View file
    Original file line number Diff line number Diff line change
    @@ -1,6 +1,6 @@
    # Java Functional Programming

    *This article will take you the next level in java. Are you ready!*
    *This article will take you to the next level in java. Are you ready!*

    ## Introduction

    @@ -16,10 +16,10 @@
    By learning more about lazy expressions and precisely lambdas and references in this section you will be able to make your code so lazy. Also will make the use of your hardware optimal.
    3) Functional interfaces:

    This is actually the main section in which you will be able to see real example of the implementation of code and you will understand how to use all what learnt. Still more concrete examples will be in the last section.
    This is actually the main section in which you will be able to see real example of the implementation of code and you will understand how to use all what you have learnt. Still more concrete examples will be in the last section.
    4) Optional:

    This brief section will take you back to bad memory of your first steps learning java, and exactly to the scary NullPointerException. But, this time you will be able to take control over every thing with no worries of any unpredictable null values problems.
    This brief section will take you back to bad memory of your first steps learning java, and exactly to the scary `NullPointerException`. But, this time you will be able to take control over every thing with no worries of any unpredictable null value problems.

    Finally, you will work on real examples and learn some specific tricks that will alter your programming style to the best!

    @@ -28,23 +28,24 @@ To understand exactly why I choose to follow this planing You need to understand

    ## 1) Java 8 Stream API

    Java 8 Stream is a sequence of elements from certain source, on which we can perform basic aggregate operations. This source can be a collection, array or a stream - this is called *pip-lining*. In contrast to collections, streams aren't data structure. They allow to extract the required value only when we need it. Also they support lazy evaluation and were initially created to be used with lambdas(refer to the second part). They are contained under the package java.util.stream. There is a very large set of operations to perform on a stream. The majority of them return a stream so that we can perform more operations. Moreover streams don't store data nor changes. They just perform iteration internally once and then return a result. So we say that they are **consumable and functional in nature**. On more powerful point for stream is that they are possibly unbounded. Thus, you can perform operations on the first and last elements of a stream with no worries because they also keep the same order of elements as the source.
    Java 8 Stream is a sequence of elements from certain source, on which we can perform basic aggregate operations. This source can be a collection, array or a stream - this is called *pip-lining*. In contrast to collections, streams aren't data structure. They allow to extract the required value only when we need it. Also they support lazy evaluation and were initially created to be used with lambdas(refer to the second part). They are contained under the package java.util.stream. There is a very large set of operations to perform on a stream. The majority of them return a stream so that we can perform more operations. Moreover streams don't store data nor changes. They just perform iteration internally once and then return a result. So we say that they are **consumable and functional in nature**. On more powerful point for stream is that they are possibly unbounded. Thus, you can perform operations on the first and last elements of a stream with no worries for its size or the order of elements because they also keep the same order of elements as the source.

    *This article will just give some important and highly used examples of functions and operations. If you were looking for more operations that java offers, you can look for them later on by yourself.*
    *This article will just give some important and highly used examples of functions and operations. If you were looking for more operations that java offers, you can look for them [here](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html).*

    In a nutshell:

    | Collection | Stream |
    | --------- | ----- |
    | under the java.util package | under the java.util.stream package |
    | in memory data structure | only for processing data |
    | all value must be computed then stored(eager) | allow operations on only the required values(lazy) |
    | we can perform operations as much as we want on collection | the elements of a stream are only visited once during the life of a stream |
    | all values must be computed then stored (eager) | allow operations on only the required values (lazy) |
    | we can perform operations as much as we want on collection | the elements of a stream are only visited once during the life of a stream (if you want to visit them again use an other stream!) |
    | must have certain size | doesn't need a fixed size. Yet, we can get the first/last elements |

    In the next example we gonna use the following import:

    import java.util.List;
    >import java.util.List;
    If you take this list of friends:

    ``` java
    @@ -65,21 +66,21 @@ I think this code is clear for you. But other method to do the same thing with n

    ``` java
    friends
    .stream()//create stream of friends
    .forEach(n->System.out.println( n.length()));//Then print successively each one of them
    .stream()//create stream of friends
    .forEach(n->System.out.println( n.length()));//Then print successively each one of them
    ```

    *Please refer to the next section to understand what are this expressions t -> expression*.
    *Please refer to the next section to understand what are these expressions: `t -> expression`*.

    ***

    ## 2) Lazy expressions

    Lazy expressions or lazy evaluation is a strategy of coding and also a mindset. You will find a lot of complex explanations to what exactly a lazy evaluation is. Yet, it is all about how to make your code **lazier**, and by this I mean **optimal**. This could be done by postpone the execution of a function until we really need it be executed. Java use lazy when it comes to the evaluation of logical arguments,e.g. in `f1() || f2()` , the call of `f2()` is never performed if `f1()` returns a boolean true. Still, a method is executed as soon as it is called. On the other hand, if a lazy method wasn't called, then it will just lie around and do nothing. However, we are often tempted towards writing a code which is executed eagerly, because it is easy to write and to reason about. But sometimes it is just a waste of time and hardware resources to if a method doesn't use all the passed arguments. In this section we gonna focus exclusively on lambdas, method reference, and how they make your code lazier.
    Lazy expressions or lazy evaluation is a strategy of coding and also a mindset. You will find a lot of complex explanations to what exactly a lazy evaluation is. Yet, it is all about how to make your code **lazier**, and by this I mean **optimal**. This could be done by postpone the execution of a function until we really need it be executed. Java is lazy when it comes to the evaluation of logical arguments,e.g. in `f1() || f2()` , the call of `f2()` is never performed if `f1()` returns a boolean true. Still, a method is executed as soon as it is called. On the other hand, if a lazy method wasn't called, then it will just lay around whithout doing anything. However, we are often tempted towards writing a code which is executed eagerly, because it is easy to write and to understand the logic behind it. But sometimes it is just a waste of time and hardware resources if a method doesn't use all the passed arguments. In this section we gonna focus exclusively on lambdas, method reference, and how they make your code lazier.

    * Method reference

    Method reference refers to a method from class or object using class::methodName type syntax. There is different types of available method references in java 8. For example:
    Method reference refers to a method from class or object using `class::methodName` type syntax. There is different types of available method references in java 8. For example:

    | Explanation | Form | Example |
    | ------ | ----- | ---- |
    @@ -91,17 +92,17 @@ Method reference refers to a method from class or object using class::methodName
    * Lambda expression

    Lambda expression are also called anonymous function, i.e., a function with no name and any identifier.
    They are nameless functions given as constant values, and written exactly in the place where it’s needed, typically as a parameter to some other function. They are writing in this form:`(parameters) -> expression`; which means that `expression` is preformed when call it on the value that takes the variables `parameters`.( For example, this expression `(x, y) -> x + y` returns the result of the addition of `x` and `y`;
    They are nameless functions given as constant values, and written exactly in the place where it’s needed, typically as a parameter to some other function. They are writing in this form:`(parameters) -> expression`; which means that `expression` is preformed when it is called, on the value that takes the variables `parameters`.( For example, this expression `(x, y) -> x + y` returns the result of the addition of `x` and `y`, also this expression `(x) -> System.out.println(x)` prints the value given to the argument `x`;

    In the example above `.forEach(n->System.out.println( n.length()));` means that we gonna perform the action between brackets on each element of our stream, which is to print them one by one.

    Moreover, the code above also can be written as following with some small changes:

    ``` java
    friends
    .stream()
    .map(String::length)//Map each name to its length. As result we get a stream of lengths.
    .forEach(System.out::println);//Print each element of the stream.
    .stream()
    .map(String::length)//Map each name to its length. As result we get a stream of lengths.
    .forEach(System.out::println);//Print each element of the stream.
    ```

    ***
    @@ -130,7 +131,7 @@ static void fct(){//default static method
    }
    ```

    * Default method are a related topic. Since, they are methods that can have an implementation into an interface! This implementation by default can be either kept as it is, or overridden. We can make a default method by adding the keyword `default` or, and this is so cool, by making it `static` with no need to add the `default` keyword. I want dive into more details that you can look for later(believe me this new feature is awesome), but a good question to ask is what also they provide so that I putted them into this section? **Well, because default methods enable the lambdas functionality in java.** Take a look to this example from `java.lang.Iterable`:
    * Default methods are a related topic. Since, they are methods that can have an implementation into an interface! This implementation by default can be either kept as it is, or overridden. We can make a default method by adding the keyword `default` or, and this is so cool, by making it `static` with no need to add the `default` keyword. I won't dive into more details that you can look for later(believe me this new feature is awesome so please check the [references](#references)), but a good question to ask is what also they provide so that I putted them into this section? **Well, because default methods enable the lambdas functionality in java.** Take a look to this example from `java.lang.Iterable`:

    ``` java
    //This method allow you to perform action on collection
    @@ -144,12 +145,12 @@ action.accept(t);
    Before java 8 you have to iterate on your collection using the loop for. But now you can do something like this (I reused the first example here):
    */
    friends
    .stream()
    .forEach(System.out::println);//to print all the friends names.
    .stream()
    .forEach(System.out::println);//to print all the friends names.
    //Or;
    friends
    .stream()
    .forEach(f -> System.out.println(f));
    .stream()
    .forEach(f -> System.out.println(f));
    ```

    * Also, `java.util` has a set of pre-implimented functional interfaces like the following examples:
    @@ -161,7 +162,7 @@ friends
    | **Supplier< TypeOfInput>** | Represents a supplier of results. |
    | **Predicate< TypeOfInput>** | Represents a predicate (boolean-valued function) of one argument. |

    I will just give an exhaustive example of implementation of a `function`. Every thing else goes the same way. Yet, if you want the full list you can check the provided documentation of *[Oracle](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html)*.
    I will just give an exhaustive example of implementation of a `function`. Everything else goes the same way. Yet, if you want the full list you can check the provided documentation of *[Oracle](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html)*.

    ``` java
    /*
    @@ -187,7 +188,7 @@ If you want more easy examples for this topic you can check my github [repositor

    ## 4) Optional

    When I was a 'newbie' to java I hated it because of one scary exception that keeps popping up on my screen: The java famous `NullPointerException`. To be honest it was of some stupid required initial values, so java is not the one to blame here. Later, I learnt about the class `Optional` of the package `java.util`. Optional, is in fact a value that can be null or not null. Yet, you have a huge set of tools and methods to manipulate it. If it was *present*, if you want to *throw* a specific exception *or else*, if you want to *get* the value you have methods to do so in this class.
    When I was a 'newbie' to java I hated it because of one scary exception that keeps popping up on my screen: The java famous `NullPointerException`. To be honest it was because some stupid, missed yet required initial values, so java is not the one to blame here. Later, I learnt about the class `Optional` of the package `java.util`. Optional, is in fact a value that can be null or not null. You have a huge set of tools and methods to manipulate it. If it was *present*, if you want to *throw* a specific exception, if you want to *get* the value, *or else* you have methods to do so in this class.

    So let us go directly to see some examples:

    @@ -200,8 +201,8 @@ So let us go directly to see some examples:
    If you want to print a value when only it is present.
    */
    System.out.println(Optional
    .ofNullable(null)
    .orElseGet(() -> "value to show by default"));
    .ofNullable(null)
    .orElseGet(() -> "value to show by default"));
    /*
    If you want to print a value when only it is present, or just throw an exception.
    */
    @@ -211,7 +212,7 @@ System.out.println(Optional.ofNullable(null).orElseThrow(SomeUserCostumizedOrAny

    //Lambda
    System.out.println(Optional.ofNullable(null)
    .orElseThrow(()-> new SomeUserCostumizedOrAnyException("the default value is missed")));
    .orElseThrow(()-> new SomeUserCostumizedOrAnyException("the default value is missed")));
    /*
    If you want to check of the value is present and then print the String email(you have first change null by something like this "xyz@example.com")
    */
    @@ -224,7 +225,7 @@ System.out.println("Sending email to "+v+"."),
    A last comparison, in case of you want to just get the value.
    */

    //normal method(imperative approach in which you declare all your variables)
    //normal method(imperative approach in which you declare all your variables and explicitly the logic of how to get the wanted result)
    String s="present value";
    if(s==null){
    System.out.println("s is null");
    @@ -250,9 +251,14 @@ In this article you learnt:
    | Section | Importance |
    | ------ | ----- |
    | Streams | Streams make you code lazy and by only using the required values in a data source and by having a powerful set of aggregate methods to use |
    | Lazy expressions | Lambdas and method reference change your code approach to be more declarative and also lazier |
    | Streams | Streams make your code lazy by only using the required values in a data source. To do so, you have a powerful set of aggregate methods to use |
    | Lazy expressions | Lambdas and method reference change your coding style to be more declarative and also lazier |
    | Functional Interfaces | This part serves as the theory behind functional programming in java and some good examples to understand it. |
    | Optional | This class works lot with streams and functional interfaces, in case of null values. It will allow you to avoid the struggle of facing the `NullPointerException` every time you execute your code. |
    Thank you for reading.
    ***
    ### References
    [HowToDoInJava](https://howtodoinjava.com/java-8-tutorial/)
  5. abdorah revised this gist Dec 6, 2020. 1 changed file with 0 additions and 1 deletion.
    1 change: 0 additions & 1 deletion .md
    View file
    Original file line number Diff line number Diff line change
    @@ -254,6 +254,5 @@ In this article you learnt:
    | Lazy expressions | Lambdas and method reference change your code approach to be more declarative and also lazier |
    | Functional Interfaces | This part serves as the theory behind functional programming in java and some good examples to understand it. |
    | Optional | This class works lot with streams and functional interfaces, in case of null values. It will allow you to avoid the struggle of facing the `NullPointerException` every time you execute your code. |
    | | |
    Thank you for reading.
  6. abdorah revised this gist Dec 6, 2020. 1 changed file with 0 additions and 1 deletion.
    1 change: 0 additions & 1 deletion .md
    View file
    Original file line number Diff line number Diff line change
    @@ -160,7 +160,6 @@ friends
    | **Consumer < TypeOfInput>** | Represents an operation that accepts a single input argument and returns no result. |
    | **Supplier< TypeOfInput>** | Represents a supplier of results. |
    | **Predicate< TypeOfInput>** | Represents a predicate (boolean-valued function) of one argument. |
    | | |

    I will just give an exhaustive example of implementation of a `function`. Every thing else goes the same way. Yet, if you want the full list you can check the provided documentation of *[Oracle](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html)*.

  7. abdorah revised this gist Dec 6, 2020. 1 changed file with 0 additions and 2 deletions.
    2 changes: 0 additions & 2 deletions .md
    View file
    Original file line number Diff line number Diff line change
    @@ -41,7 +41,6 @@ In a nutshell:
    | all value must be computed then stored(eager) | allow operations on only the required values(lazy) |
    | we can perform operations as much as we want on collection | the elements of a stream are only visited once during the life of a stream |
    | must have certain size | doesn't need a fixed size. Yet, we can get the first/last elements |
    | | |

    In the next example we gonna use the following import:

    @@ -88,7 +87,6 @@ Method reference refers to a method from class or object using class::methodName
    | Reference to instance method from instance | **ClassInstance::instanceMethodName** | System.out::println equivalent to System.out.println(x) |
    | Reference to instance method from class type | **Class::instanceMethodName** | String::length equivalent to str.length() |
    | Reference to constructor | **Class::new** | ArrayList::new equivalent to new ArrayList() |
    | | |

    * Lambda expression

  8. abdorah revised this gist Dec 6, 2020. 1 changed file with 5 additions and 4 deletions.
    9 changes: 5 additions & 4 deletions .md
    View file
    Original file line number Diff line number Diff line change
    @@ -10,16 +10,16 @@

    1) Stream:

    In this section we will dive into the world of streams. We will understand them, how they work, and why we need them in the first place.
    In this section we will dive into the world of streams. We will understand them, how they work, and why we need them in the first place.
    2) Lazy expressions:

    By learning more about lazy expressions and precisely lambdas and references in this section you will be able to make your code so lazy. Also will make the use of your hardware optimal.
    By learning more about lazy expressions and precisely lambdas and references in this section you will be able to make your code so lazy. Also will make the use of your hardware optimal.
    3) Functional interfaces:

    This is actually the main section in which you will be able to see real example of the implementation of code and you will understand how to use all what learnt. Still more concrete examples will be in the last section.
    This is actually the main section in which you will be able to see real example of the implementation of code and you will understand how to use all what learnt. Still more concrete examples will be in the last section.
    4) Optional:

    This brief section will take you back to bad memory of your first steps learning java, and exactly to the scary NullPointerException. But, this time you will be able to take control over every thing with no worries of any unpredictable null values problems.
    This brief section will take you back to bad memory of your first steps learning java, and exactly to the scary NullPointerException. But, this time you will be able to take control over every thing with no worries of any unpredictable null values problems.

    Finally, you will work on real examples and learn some specific tricks that will alter your programming style to the best!

    @@ -163,6 +163,7 @@ friends
    | **Supplier< TypeOfInput>** | Represents a supplier of results. |
    | **Predicate< TypeOfInput>** | Represents a predicate (boolean-valued function) of one argument. |
    | | |

    I will just give an exhaustive example of implementation of a `function`. Every thing else goes the same way. Yet, if you want the full list you can check the provided documentation of *[Oracle](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html)*.

    ``` java
  9. abdorah revised this gist Dec 6, 2020. 1 changed file with 19 additions and 15 deletions.
    34 changes: 19 additions & 15 deletions .md
    View file
    Original file line number Diff line number Diff line change
    @@ -10,16 +10,16 @@

    1) Stream:

    In this section we will dive into the world of streams. We will understand them, how they work, and why we need them in the first place.
    In this section we will dive into the world of streams. We will understand them, how they work, and why we need them in the first place.
    2) Lazy expressions:

    By learning more about lazy expressions and precisely lambdas and references in this section you will be able to make your code so lazy. Also will make the use of your hardware optimal.
    By learning more about lazy expressions and precisely lambdas and references in this section you will be able to make your code so lazy. Also will make the use of your hardware optimal.
    3) Functional interfaces:

    This is actually the main section in which you will be able to see real example of the implementation of code and you will understand how to use all what learnt. Still more concrete examples will be in the last section.
    This is actually the main section in which you will be able to see real example of the implementation of code and you will understand how to use all what learnt. Still more concrete examples will be in the last section.
    4) Optional:

    This brief section will take you back to bad memory of your first steps learning java, and exactly to the scary NullPointerException. But, this time you will be able to take control over every thing with no worries of any unpredictable null values problems.
    This brief section will take you back to bad memory of your first steps learning java, and exactly to the scary NullPointerException. But, this time you will be able to take control over every thing with no worries of any unpredictable null values problems.

    Finally, you will work on real examples and learn some specific tricks that will alter your programming style to the best!

    @@ -125,6 +125,10 @@ default void fct1(){//default method
    default void fct2(){//default method
    //Method body
    }

    static void fct(){//default static method
    //Method body
    }
    }
    ```

    @@ -142,23 +146,23 @@ action.accept(t);
    Before java 8 you have to iterate on your collection using the loop for. But now you can do something like this (I reused the first example here):
    */
    friends
    .stream()
    .forEach(System.out::println);//to print all the friends names.
    .stream()
    .forEach(System.out::println);//to print all the friends names.
    //Or;
    friends
    .stream()
    .forEach(f -> System.out.println(f));
    .stream()
    .forEach(f -> System.out.println(f));
    ```

    * Also, `java.util` has a set of pre-implimented functional interfaces like the following examples:

    | Fucntional interface | Definition |
    | Functional interface | Definition |
    | - | - |
    | **Function < TypeOfInput,TypeOfReturn>** | Represents a function that accepts one argument and produces a result. |
    | **Consumer < TypeOfInput>** | Represents an operation that accepts a single input argument and returns no result. |
    | **Supplier< TypeOfInput>** | Represents a supplier of results. |
    | **Predicate< TypeOfInput>** | Represents a predicate (boolean-valued function) of one argument. |
    | | |
    | | |
    I will just give an exhaustive example of implementation of a `function`. Every thing else goes the same way. Yet, if you want the full list you can check the provided documentation of *[Oracle](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html)*.

    ``` java
    @@ -168,11 +172,11 @@ This example represente a method that increment its int argument by one.

    //It would be something like this:
    int increment(int i){
    return i+1;
    }
    return i+1;
    }

    /*
    With fonctional interface "Function" it becomes:
    With functional interface "Function" it becomes:
    Don't forget to import:
    import java.util.function.Function;
    */
    @@ -219,7 +223,7 @@ System.out.println("Sending email to "+v+"."),
    () -> System.out.println("Cannot send emails!")
    );
    /*
    A last comparaison, in case of you want to just get the value.
    A last comparison, in case of you want to just get the value.
    */

    //normal method(imperative approach in which you declare all your variables)
    @@ -248,7 +252,7 @@ In this article you learnt:
    | Section | Importance |
    | ------ | ----- |
    | Streams | Streams make you code lazy and by only using the required values in a data source and by having a powerful set of aggregate methodes to use |
    | Streams | Streams make you code lazy and by only using the required values in a data source and by having a powerful set of aggregate methods to use |
    | Lazy expressions | Lambdas and method reference change your code approach to be more declarative and also lazier |
    | Functional Interfaces | This part serves as the theory behind functional programming in java and some good examples to understand it. |
    | Optional | This class works lot with streams and functional interfaces, in case of null values. It will allow you to avoid the struggle of facing the `NullPointerException` every time you execute your code. |
  10. abdorah renamed this gist Dec 6, 2020. 1 changed file with 0 additions and 0 deletions.
    0 md → .md
    View file
    File renamed without changes.
  11. abdorah created this gist Dec 6, 2020.
    257 changes: 257 additions & 0 deletions md
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,257 @@
    # Java Functional Programming

    *This article will take you the next level in java. Are you ready!*

    ## Introduction

    >This article is basically a set of examples of multiple tools provided by Java 8. Those tools have helped to make programming way more easier and optimal(even in terms of hardware resources), using a declarative approach. Hence, we don't have to tell many details, but only what we want to achieve by our code. I should highlight also the fact that this pack of tools is something that a java developer *"must"* know.

    ### Map

    1) Stream:

    In this section we will dive into the world of streams. We will understand them, how they work, and why we need them in the first place.
    2) Lazy expressions:

    By learning more about lazy expressions and precisely lambdas and references in this section you will be able to make your code so lazy. Also will make the use of your hardware optimal.
    3) Functional interfaces:

    This is actually the main section in which you will be able to see real example of the implementation of code and you will understand how to use all what learnt. Still more concrete examples will be in the last section.
    4) Optional:

    This brief section will take you back to bad memory of your first steps learning java, and exactly to the scary NullPointerException. But, this time you will be able to take control over every thing with no worries of any unpredictable null values problems.

    Finally, you will work on real examples and learn some specific tricks that will alter your programming style to the best!

    To understand exactly why I choose to follow this planing You need to understand the relation between those parts. Because, this selection of topics doesn't recover every thing about java and functional programming. Still, it will be your main support to learn more.
    ***

    ## 1) Java 8 Stream API

    Java 8 Stream is a sequence of elements from certain source, on which we can perform basic aggregate operations. This source can be a collection, array or a stream - this is called *pip-lining*. In contrast to collections, streams aren't data structure. They allow to extract the required value only when we need it. Also they support lazy evaluation and were initially created to be used with lambdas(refer to the second part). They are contained under the package java.util.stream. There is a very large set of operations to perform on a stream. The majority of them return a stream so that we can perform more operations. Moreover streams don't store data nor changes. They just perform iteration internally once and then return a result. So we say that they are **consumable and functional in nature**. On more powerful point for stream is that they are possibly unbounded. Thus, you can perform operations on the first and last elements of a stream with no worries because they also keep the same order of elements as the source.

    *This article will just give some important and highly used examples of functions and operations. If you were looking for more operations that java offers, you can look for them later on by yourself.*

    In a nutshell:

    | Collection | Stream |
    | --------- | ----- |
    | under the java.util package | under the java.util.stream package |
    | in memory data structure | only for processing data |
    | all value must be computed then stored(eager) | allow operations on only the required values(lazy) |
    | we can perform operations as much as we want on collection | the elements of a stream are only visited once during the life of a stream |
    | must have certain size | doesn't need a fixed size. Yet, we can get the first/last elements |
    | | |

    In the next example we gonna use the following import:

    import java.util.List;
    If you take this list of friends:

    ``` java
    List<String> friends = List.of("Mohamed","Abderrahmane","Ajar","Omar","Youssef");
    ```

    Imagine we want to print the length of each name. Normally, your code would be something like this:

    ``` java
    int[] r = new int[5];
    for (int i = 0;i<5;i++) {
    r[i] = friends.get(i).length();
    System.out.println(r[i]);
    }
    ```

    I think this code is clear for you. But other method to do the same thing with no need to declare any variable is the following:

    ``` java
    friends
    .stream()//create stream of friends
    .forEach(n->System.out.println( n.length()));//Then print successively each one of them
    ```

    *Please refer to the next section to understand what are this expressions t -> expression*.

    ***

    ## 2) Lazy expressions

    Lazy expressions or lazy evaluation is a strategy of coding and also a mindset. You will find a lot of complex explanations to what exactly a lazy evaluation is. Yet, it is all about how to make your code **lazier**, and by this I mean **optimal**. This could be done by postpone the execution of a function until we really need it be executed. Java use lazy when it comes to the evaluation of logical arguments,e.g. in `f1() || f2()` , the call of `f2()` is never performed if `f1()` returns a boolean true. Still, a method is executed as soon as it is called. On the other hand, if a lazy method wasn't called, then it will just lie around and do nothing. However, we are often tempted towards writing a code which is executed eagerly, because it is easy to write and to reason about. But sometimes it is just a waste of time and hardware resources to if a method doesn't use all the passed arguments. In this section we gonna focus exclusively on lambdas, method reference, and how they make your code lazier.

    * Method reference

    Method reference refers to a method from class or object using class::methodName type syntax. There is different types of available method references in java 8. For example:

    | Explanation | Form | Example |
    | ------ | ----- | ---- |
    | Reference to static method | **Class::staticMethodName** | Math::max equivalent to Math.max(x,y) |
    | Reference to instance method from instance | **ClassInstance::instanceMethodName** | System.out::println equivalent to System.out.println(x) |
    | Reference to instance method from class type | **Class::instanceMethodName** | String::length equivalent to str.length() |
    | Reference to constructor | **Class::new** | ArrayList::new equivalent to new ArrayList() |
    | | |

    * Lambda expression

    Lambda expression are also called anonymous function, i.e., a function with no name and any identifier.
    They are nameless functions given as constant values, and written exactly in the place where it’s needed, typically as a parameter to some other function. They are writing in this form:`(parameters) -> expression`; which means that `expression` is preformed when call it on the value that takes the variables `parameters`.( For example, this expression `(x, y) -> x + y` returns the result of the addition of `x` and `y`;

    In the example above `.forEach(n->System.out.println( n.length()));` means that we gonna perform the action between brackets on each element of our stream, which is to print them one by one.

    Moreover, the code above also can be written as following with some small changes:

    ``` java
    friends
    .stream()
    .map(String::length)//Map each name to its length. As result we get a stream of lengths.
    .forEach(System.out::println);//Print each element of the stream.
    ```

    ***

    ## 3) Functional interfaces

    It's time to dive more in one of the main innovations that java 8 has come with.

    * Overall, Functional interfaces are interfaces that permit exactly one abstract method inside them, in addition to as many as you like of default methods. Since they are not abstract because they have an implementation (I should also highlight the fact that default functions are a revolutionary addition in java 8). Functional interfaces are also named **Single Abstract Method interfaces *(SAM Interfaces)***. In Java 8, functional interfaces can be represented using lambda expressions, method reference and constructor references as well. It is optional to add `@FunctionalInterface` annotation to a functional interface to define one. For example we can have something like this:

    ``` java
    @FunctionalInterface
    public interface MyInterface
    {
    public void job();//one abstract method
    default void fct1(){//default method
    //Method body
    }
    default void fct2(){//default method
    //Method body
    }
    }
    ```

    * Default method are a related topic. Since, they are methods that can have an implementation into an interface! This implementation by default can be either kept as it is, or overridden. We can make a default method by adding the keyword `default` or, and this is so cool, by making it `static` with no need to add the `default` keyword. I want dive into more details that you can look for later(believe me this new feature is awesome), but a good question to ask is what also they provide so that I putted them into this section? **Well, because default methods enable the lambdas functionality in java.** Take a look to this example from `java.lang.Iterable`:

    ``` java
    //This method allow you to perform action on collection
    default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
    action.accept(t);
    }
    }
    /*
    Before java 8 you have to iterate on your collection using the loop for. But now you can do something like this (I reused the first example here):
    */
    friends
    .stream()
    .forEach(System.out::println);//to print all the friends names.
    //Or;
    friends
    .stream()
    .forEach(f -> System.out.println(f));
    ```

    * Also, `java.util` has a set of pre-implimented functional interfaces like the following examples:

    | Fucntional interface | Definition |
    | - | - |
    | **Function < TypeOfInput,TypeOfReturn>** | Represents a function that accepts one argument and produces a result. |
    | **Consumer < TypeOfInput>** | Represents an operation that accepts a single input argument and returns no result. |
    | **Supplier< TypeOfInput>** | Represents a supplier of results. |
    | **Predicate< TypeOfInput>** | Represents a predicate (boolean-valued function) of one argument. |
    | | |
    I will just give an exhaustive example of implementation of a `function`. Every thing else goes the same way. Yet, if you want the full list you can check the provided documentation of *[Oracle](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html)*.

    ``` java
    /*
    This example represente a method that increment its int argument by one.
    */

    //It would be something like this:
    int increment(int i){
    return i+1;
    }

    /*
    With fonctional interface "Function" it becomes:
    Don't forget to import:
    import java.util.function.Function;
    */
    Function<Integer, Integer> increment = i -> ++i;
    ```

    If you want more easy examples for this topic you can check my github [repository](https://github.com/abdorah/java_functional_programming).

    ***

    ## 4) Optional

    When I was a 'newbie' to java I hated it because of one scary exception that keeps popping up on my screen: The java famous `NullPointerException`. To be honest it was of some stupid required initial values, so java is not the one to blame here. Later, I learnt about the class `Optional` of the package `java.util`. Optional, is in fact a value that can be null or not null. Yet, you have a huge set of tools and methods to manipulate it. If it was *present*, if you want to *throw* a specific exception *or else*, if you want to *get* the value you have methods to do so in this class.

    So let us go directly to see some examples:

    ``` java

    /*In all the example you can change the value 'null' and the SomeUserCostumizedOrAnyException by something else.
    */

    /*
    If you want to print a value when only it is present.
    */
    System.out.println(Optional
    .ofNullable(null)
    .orElseGet(() -> "value to show by default"));
    /*
    If you want to print a value when only it is present, or just throw an exception.
    */

    // method reference
    System.out.println(Optional.ofNullable(null).orElseThrow(SomeUserCostumizedOrAnyException::new));

    //Lambda
    System.out.println(Optional.ofNullable(null)
    .orElseThrow(()-> new SomeUserCostumizedOrAnyException("the default value is missed")));
    /*
    If you want to check of the value is present and then print the String email(you have first change null by something like this "xyz@example.com")
    */

    Optional.ofNullable(null).ifPresentOrElse(v->
    System.out.println("Sending email to "+v+"."),
    () -> System.out.println("Cannot send emails!")
    );
    /*
    A last comparaison, in case of you want to just get the value.
    */

    //normal method(imperative approach in which you declare all your variables)
    String s="present value";
    if(s==null){
    System.out.println("s is null");
    } else {
    System.out.println(s);
    }

    //new method with Optional (declarative approach in which you just describe what you want as result exactly)
    System.out.println(Optional.ofNullable("present value").orElse("s is null"));

    //Or just simply
    System.out.println(Optional.of("present value").get());

    ```

    ***

    ### Conclusion

    The main goal of this article was to teach you about declarative approach of programming in java. I hope I achieved this goal! But before to wrap up, I just want to remind you of the fact that this should serve as an opening and the given article and examples shouldn't be the last thing you see. So, please keep practicing to learn.

    In this article you learnt:

    | Section | Importance |
    | ------ | ----- |
    | Streams | Streams make you code lazy and by only using the required values in a data source and by having a powerful set of aggregate methodes to use |
    | Lazy expressions | Lambdas and method reference change your code approach to be more declarative and also lazier |
    | Functional Interfaces | This part serves as the theory behind functional programming in java and some good examples to understand it. |
    | Optional | This class works lot with streams and functional interfaces, in case of null values. It will allow you to avoid the struggle of facing the `NullPointerException` every time you execute your code. |
    | | |

    Thank you for reading.