Add functional basics tutorial

Author: tboychuk

README.md

@@ -1,5 +1,6 @@
 # <img src="https://raw.githubusercontent.com/bobocode-projects/resources/master/image/logo_transparent_background.png" height=50/>Java 8, 9 functional features tutorial
 The list of tutorials on functional programming techniques and features in Java
+* [Functional programming basics](https://github.com/bobocode-projects/java-functional-features-tutorial/tree/master/functional-programming-basics)
 * [Lambdas](https://github.com/bobocode-projects/java-functional-features-tutorial/tree/master/lambdas)
 * [Stream API](https://github.com/bobocode-projects/java-functional-features-tutorial/tree/master/stream-api)
 * [Optional](https://github.com/bobocode-projects/java-functional-features-tutorial/tree/master/optional)

functional-programming-basics/README.MD

@@ -0,0 +1,66 @@
+# <img src="https://raw.githubusercontent.com/bobocode-projects/resources/master/image/logo_transparent_background.png" height=50/> Functional programming tutorial
+
+This is the tutorial on functional programming basics
+### Pre-conditions :heavy_exclamation_mark:
+You're supposed to be familiar with OOP, have basic knowledge of JDK, and be able to write Java code. 
+
+### See also :point_down:
+* [Tutorial on Lambdas](https://github.com/bobocode-projects/java-functional-features-tutorial/tree/master/lambdas)
+* [Tutorial on Stream API](https://github.com/bobocode-projects/java-8-tutorial/tree/master/stream-api)
+* [Tutorial on Optional](https://github.com/bobocode-projects/java-functional-features-tutorial/tree/master/optional)
+##
+The concept of **functional programming** is based on [λ-calculus](https://en.wikipedia.org/wiki/Lambda_calculus). Which
+brings the idea of program that **does not use mutable variables**
+
+Various functional languages like [Clojure](https://clojure.org/) have been using this approach for the long time. **Java** 
+was initially created as pure OO language, but since **version 8** it offers an ability to use either **OO and functional
+ approaches.** 
+ 
+Consider an program that calculates **the sum of first 20 prime numbers**.
+
+Here's an OO-based implementation:
+
+```java
+public class OOSumOfPrimes {
+    public static void main(String[] args) {
+        int sumOfPrimes = 0;
+        for (int i = 0, primes = 0; primes < 20; i++) {
+            if (isPrime(i)) {
+                sumOfPrimes += i;
+                primes++;
+            }
+        }
+
+        System.out.println("Sum of first 20 primes: " + sumOfPrimes);
+    }
+
+    private static boolean isPrime(int n) {
+        for (int i = 2; i < n; i++) {
+            if (n % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+``` 
+     
+And this is the functional-based implementation:
+```java
+public class FunctionalSumOfPrimes {
+    public static void main(String[] args) {
+        IntStream.iterate(0, i -> i + 1)
+                .filter(FunctionalSumOfPrimes::isPrime)
+                .limit(20)
+                .reduce((a, b) -> a + b)
+                .ifPresent(sum -> System.out.println("Sum of first 20 primes: " + sum));
+    }
+
+    private static boolean isPrime(int n) {
+        return IntStream.range(2, n)
+                .noneMatch(i -> n % i == 0);
+    }
+}
+```     
+
+As you can see there is **no mutable variables** in the second example

functional-programming-basics/pom.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>java-functional-features-tutorial</artifactId>
+        <groupId>com.bobocode</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>functional-programming-basics</artifactId>
+
+
+</project>

functional-programming-basics/src/main/java/com/bobocode/FunctionalSumOfPrimes.java

@@ -0,0 +1,24 @@
+package com.bobocode;
+
+import java.util.stream.IntStream;
+
+/**
+ * This example demonstrates how to use functional approach in Java. The program calculates the sum of first 20 prime
+ * numbers without using mutable variables
+ *
+ * See {@link OOSumOfPrimes}
+ */
+public class FunctionalSumOfPrimes {
+    public static void main(String[] args) {
+        IntStream.iterate(0, i -> i + 1)
+                .filter(FunctionalSumOfPrimes::isPrime)
+                .limit(20)
+                .reduce((a, b) -> a + b)
+                .ifPresent(sum -> System.out.println("Sum of first 20 primes: " + sum));
+    }
+
+    private static boolean isPrime(int n) {
+        return IntStream.range(2, n)
+                .noneMatch(i -> n % i == 0);
+    }
+}

functional-programming-basics/src/main/java/com/bobocode/OOSumOfPrimes.java

@@ -0,0 +1,31 @@
+package com.bobocode;
+
+/**
+ * This examples demonstrates how to calculate the sum of prime numbers using OO approach. The point is that to perform
+ * this calculation in OOP-style we have to use mutable variables (e.g. sumOfPrimes, i, primes)
+ *
+ * See {@link FunctionalSumOfPrimes}
+ */
+public class OOSumOfPrimes {
+    public static void main(String[] args) {
+        int sumOfPrimes = 0;
+        for (int i = 0, primes = 0; primes < 20; i++) {
+            if (isPrime(i)) {
+                sumOfPrimes += i;
+                primes++;
+            }
+        }
+
+        System.out.println("Sum of first 20 primes: " + sumOfPrimes);
+    }
+
+    private static boolean isPrime(int n) {
+        for (int i = 2; i < n; i++) {
+            if (n % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+}

pom.xml

@@ -14,6 +14,7 @@
         <module>stream-api</module>
         <module>optional</module>
         <module>account-data</module>
+        <module>functional-programming-basics</module>
     </modules>
 
     <properties>