My feature branch

java-8/src/com/learnJavaMyVersion/constructorreference/ConstructorReference.java

@@ -0,0 +1,15 @@
+package com.learnJavaMyVersion.constructorreference;
+
+import com.learnJava.data.Student;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class ConstructorReference {
+   static Supplier<Student> studentSupplier = Student::new;
+   static Function<String,Student> studentFunction = Student::new;
+    public static void main(String[] args) {
+        System.out.println(studentSupplier.get());
+        System.out.println(studentFunction.apply("ABC"));
+    }
+}

java-8/src/com/learnJavaMyVersion/functionalInterfaces/BiConsumerExample.java

@@ -0,0 +1,34 @@
+package com.learnJavaMyVersion.functionalInterfaces;
+
+import com.learnJava.data.Student;
+import com.learnJava.data.StudentDataBase;
+
+import java.util.List;
+import java.util.function.BiConsumer;
+
+public class BiConsumerExample {
+
+    public static void  nameAndActivities(){
+        System.out.println("******  Inside nameAndActivities() method **********");
+        BiConsumer<String,List<String>> biConsumer = (name,activities) -> System.out.println(name +" : "+ activities);
+        List<Student> studentList = StudentDataBase.getAllStudents();
+        studentList.forEach((student) -> biConsumer.accept(student.getName(),student.getActivities()));
+    }
+
+    public static void main(String[] args) {
+        BiConsumer <String,String> biConsumer = (a,b) ->{
+            System.out.println("a: "+ a +", b: "+ b);
+        };
+        BiConsumer<Integer,Integer> multiplication = (a,b) ->{
+            System.out.println("Multiplication:  "+ a*b);
+        };
+        BiConsumer<Integer,Integer> division = (a,b) ->{
+            System.out.println("division:  "+ a/b);
+        };
+
+        biConsumer.accept("Java7","Java8");
+        multiplication.andThen(division).accept(10,5);
+
+        nameAndActivities();
+    }
+}

java-8/src/com/learnJavaMyVersion/functionalInterfaces/BiFunctionExample.java

@@ -0,0 +1,27 @@
+package com.learnJavaMyVersion.functionalInterfaces;
+
+import com.learnJava.data.Student;
+import com.learnJava.data.StudentDataBase;
+import com.oracle.tools.packager.mac.MacAppBundler;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiFunction;
+import java.util.function.Predicate;
+
+public class BiFunctionExample {
+
+    static BiFunction<List<Student>, Predicate<Student>, Map<String,Double>> biFunction =((studentList, studentPredicate) -> {
+        Map<String,Double> studentGpaMap = new HashMap<>();
+        studentList.forEach(student -> {
+            if (studentPredicate.test(student)){
+                studentGpaMap.put(student.getName(),student.getGpa());
+            }
+        });
+        return studentGpaMap;
+    });
+    public static void main(String[] args) {
+        System.out.println(biFunction.apply(StudentDataBase.getAllStudents(),PredicateStudentExample.predicate));
+    }
+}

java-8/src/com/learnJavaMyVersion/functionalInterfaces/BinaryOperatorExample.java

@@ -0,0 +1,19 @@
+package com.learnJavaMyVersion.functionalInterfaces;
+
+import java.util.Comparator;
+import java.util.function.BinaryOperator;
+
+public class BinaryOperatorExample {
+
+    static Comparator<Integer> comparator = (a,b) -> a.compareTo(b);
+    public static void main(String[] args) {
+        BinaryOperator<Integer> binaryOperator = (a, b) -> a*b;
+
+        System.out.println(binaryOperator.apply(3,4));
+
+       BinaryOperator<Integer> maxBy = BinaryOperator.maxBy(comparator);
+        System.out.println("Result of Max by is : " + maxBy.apply(3,4));
+        BinaryOperator<Integer> minBy = BinaryOperator.minBy(comparator);
+        System.out.println("Result of Min by is : " + minBy.apply(3,4));
+    }
+}

java-8/src/com/learnJavaMyVersion/functionalInterfaces/ConsumerExample.java

@@ -0,0 +1,42 @@
+package com.learnJavaMyVersion.functionalInterfaces;
+
+import com.learnJava.data.Student;
+import com.learnJava.data.StudentDataBase;
+
+import java.util.List;
+import java.util.function.Consumer;
+
+public class ConsumerExample {
+    static  Consumer <String> c1 = (s )-> System.out.println(s.toUpperCase());
+    static Consumer <Student> c2 = (student) -> System.out.println(student);
+    static Consumer <Student> c3 = (student) -> System.out.println(student.getName());
+    static  Consumer <Student> c4 = (student) -> System.out.println(student.getActivities());
+    public static void  printName(){
+        System.out.println("********Inside printName() method  *****************");
+        List<Student> studentList = StudentDataBase.getAllStudents();
+        studentList.forEach(c2);
+    }
+    public  static void printNameAndActivities(){
+        System.out.println("********Inside printNameAndActivities() method  *****************");
+        List<Student> studentList = StudentDataBase.getAllStudents();
+        studentList.forEach(c3.andThen(c4));
+    }
+
+    public  static void printNameAndActivitiesWtihCondition(){
+        System.out.println("********Inside printNameAndActivitiesWtihCondition() method  *****************");
+        List<Student> studentList = StudentDataBase.getAllStudents();
+        studentList.forEach(((student) ->{
+            if(student.getGradeLevel() >= 3 && student.getGpa() >= 3.9)
+                c3.andThen(c4).accept(student);
+        } ));
+    }
+    public static void main(String[] args) {
+
+
+
+       c1.accept("Tiedros");
+       printName();
+        printNameAndActivities();
+        printNameAndActivitiesWtihCondition();
+    }
+}

java-8/src/com/learnJavaMyVersion/functionalInterfaces/FunctionExample.java

@@ -0,0 +1,14 @@
+package com.learnJavaMyVersion.functionalInterfaces;
+
+import java.util.function.Function;
+
+public class FunctionExample {
+
+    static Function<String,String> function = (name)-> name.toUpperCase();
+    static Function<String,String> addSomething = (name)-> name.toUpperCase().concat("default");
+    public static void main(String[] args) {
+        System.out.println("The Result is : "+ function.apply("java8"));
+        System.out.println("The Result addThen is : "+ function.andThen(addSomething).apply("java8"));
+        System.out.println("The Result addThen is : "+ function.compose(addSomething).apply("java8"));
+    }
+}

java-8/src/com/learnJavaMyVersion/functionalInterfaces/FunctionStudentExample.java

@@ -0,0 +1,27 @@
+package com.learnJavaMyVersion.functionalInterfaces;
+
+import com.learnJava.data.Student;
+import com.learnJava.data.StudentDataBase;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public class FunctionStudentExample {
+
+    static Function<List<Student>, Map<String,Double>> studentFunction = (students -> {
+        Map<String,Double> studentGrademap = new HashMap<>();
+        students.forEach((student -> {
+            if(PredicateStudentExample.predicate.test(student)){
+                studentGrademap.put(student.getName(), student.getGpa());
+            }
+        }));
+        return studentGrademap;
+    } );
+
+    public static void main(String[] args) {
+
+        System.out.println(studentFunction.apply(StudentDataBase.getAllStudents()));
+    }
+}

java-8/src/com/learnJavaMyVersion/functionalInterfaces/PredicateAndConsumerExample.java

@@ -0,0 +1,33 @@
+package com.learnJavaMyVersion.functionalInterfaces;
+
+import com.learnJava.data.Student;
+import com.learnJava.data.StudentDataBase;
+
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.function.BiPredicate;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+public class PredicateAndConsumerExample {
+
+    Predicate<Student> predicate1 = (student) -> student.getGradeLevel() >= 3;
+    Predicate<Student> getPredicate2 = (student) -> student.getGpa() >= 3.9;
+    BiPredicate<Integer,Double> biPredicate = (gradeLevel,gpa)-> gradeLevel >= 3 && gpa >= 3.9;
+    BiConsumer<String,List<String>> studentBiConsumer = (name,activities) -> System.out.println(name +" : "+ activities);
+    Consumer<Student> studentConsumer = (student -> {
+     // if(predicate1.and(getPredicate2).test(student)){ //using Predicate chaining
+        if(biPredicate.test(student.getGradeLevel(),student.getGpa())){ // using biPredicate
+          studentBiConsumer.accept(student.getName(),student.getActivities());
+      }
+    });
+
+    public  void  printNameAndActivities(List<Student> studentList){
+        System.out.println("****************InSide  printNameAndActivities() method******************");
+        studentList.forEach(studentConsumer);
+    }
+    public static void main(String[] args) {
+        List<Student> studentList = StudentDataBase.getAllStudents();
+        new PredicateAndConsumerExample().printNameAndActivities(studentList);
+    }
+}

java-8/src/com/learnJavaMyVersion/functionalInterfaces/PredicateExample.java

@@ -0,0 +1,41 @@
+package com.learnJavaMyVersion.functionalInterfaces;
+
+import java.util.function.Predicate;
+
+public class PredicateExample {
+    static Predicate<Integer> predicate = (a)-> { return a%2==0;};
+    static Predicate<Integer> predicate2 = (a)-> a%2==0;
+    static Predicate<Integer> predicate3 = (a)-> a%5==0;
+
+    public static void predicateAnd(){
+        System.out.println("********Inside predicateAnd() method ***********");
+        System.out.println(predicate2.and(predicate3).test(10));
+        System.out.println(predicate2.and(predicate3).test(8));
+        System.out.println(predicate2.and(predicate3).test(9));
+    }
+
+    public static void predicateOr(){
+        System.out.println("********Inside predicateOr() method ***********");
+        System.out.println(predicate2.or(predicate3).test(10));
+        System.out.println(predicate2.or(predicate3).test(8));
+        System.out.println(predicate2.or(predicate3).test(9));
+    }
+
+    public static void predicateNegate(){
+        System.out.println("********Inside predicateNegate() method ***********");
+        System.out.println(predicate2.or(predicate3).negate().test(10));
+        System.out.println(predicate2.or(predicate3).negate().test(8));
+        System.out.println(predicate2.or(predicate3).negate().test(9));
+    }
+    public static void main(String[] args) {
+
+
+
+        System.out.println("Is 4 even number? : "+ predicate.test(4));
+        System.out.println("Is 4 even number? : "+ predicate2.test(4));
+
+        predicateAnd();
+        predicateOr();
+        predicateNegate();
+    }
+}

java-8/src/com/learnJavaMyVersion/functionalInterfaces/PredicateStudentExample.java

@@ -0,0 +1,45 @@
+package com.learnJavaMyVersion.functionalInterfaces;
+
+import com.learnJava.data.Student;
+import com.learnJava.data.StudentDataBase;
+
+import java.util.List;
+import java.util.function.Predicate;
+
+public class PredicateStudentExample {
+    static Predicate<Student> predicate = (student) -> student.getGradeLevel() >=3;
+    static Predicate<Student> predicate2 = (student) -> student.getGpa() >=3.9;
+    public static void filterStudentByGradeLevel(){
+        System.out.println("***********Inside filterStudentByGradeLevel() method*****************");
+        List<Student> studentList = StudentDataBase.getAllStudents();
+        studentList.forEach((student) ->{
+            if(predicate.test(student)){
+                System.out.println(student);
+            }
+        });
+    }
+    public static void filterStudentByGpa(){
+        System.out.println("***********Inside filterStudentByGpa() method*****************");
+        List<Student> studentList = StudentDataBase.getAllStudents();
+        studentList.forEach((student) ->{
+            if(predicate2.test(student)){
+                System.out.println(student);
+            }
+        });
+    }
+
+    public static void filterStudents(){
+        System.out.println("***********Inside filterStudents() method*****************");
+        List<Student> studentList = StudentDataBase.getAllStudents();
+        studentList.forEach((student) ->{
+            if(predicate.and(predicate2).test(student)){
+                System.out.println(student);
+            }
+        });
+    }
+    public static void main(String[] args) {
+        filterStudentByGradeLevel();
+        filterStudentByGpa();
+        filterStudents();
+    }
+}

java-8/src/com/learnJavaMyVersion/functionalInterfaces/SupplierExample.java

@@ -0,0 +1,21 @@
+package com.learnJavaMyVersion.functionalInterfaces;
+
+import com.learnJava.data.Student;
+import com.learnJava.data.StudentDataBase;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Supplier;
+
+public class SupplierExample {
+    public static void main(String[] args) {
+        Supplier<Student> studentSupplier = () -> {
+            return new Student("Adam",2,3.6,"male", Arrays.asList("swimming","basketball","vollyeball"));
+        };
+
+        Supplier<List<Student>> listSupplier = () -> StudentDataBase.getAllStudents();
+
+        System.out.println("Student is : "+studentSupplier.get());
+        System.out.println("Students are : "+ listSupplier.get());
+    }
+}

java-8/src/com/learnJavaMyVersion/functionalInterfaces/UnaryOperatorExample.java

@@ -0,0 +1,12 @@
+package com.learnJavaMyVersion.functionalInterfaces;
+
+import java.util.function.UnaryOperator;
+
+public class UnaryOperatorExample {
+
+    static UnaryOperator<String> unaryOperator = (s) -> s.concat("Default");
+    public static void main(String[] args) {
+        System.out.println(unaryOperator.apply("Java8 "));
+
+    }
+}

java-8/src/com/learnJavaMyVersion/imperativeVsDeclarativePrograming/ImperativeVsDeclarativeExample1.java

@@ -0,0 +1,28 @@
+package com.learnJavaMyVersion.imperativeVsDeclarativePrograming;
+
+import java.util.stream.IntStream;
+
+public class ImperativeVsDeclarativeExample1 {
+
+    public static void main(String[] args) {
+
+        /*
+        * Imperative - How style programming
+         */
+
+        int sum =0;
+        for(int i=0;i<=100;i++){
+            sum+=i;
+        }
+        System.out.println("Sum using imperative Approach   is : "+ sum);
+
+        /*
+        * Declarative - What style programming
+        *
+        * */
+
+        int sum1 = IntStream.rangeClosed(0, 100)
+                .sum();
+        System.out.println("Sum using declarative Approach is : "+ sum1);
+    }
+}