Add functional programming practices

Author: ssmtariq

Diff for: src/com/ssmtariq/Course.java

@@ -0,0 +1,52 @@
+package com.ssmtariq;
+
+class Course {
+	private String name;
+	private String category;
+	private int reviewScore;
+	private int noOfStudents;
+
+	public Course(String name, String category, int reviewScore, int noOfStudents) {
+		super();
+		this.name = name;
+		this.category = category;
+		this.reviewScore = reviewScore;
+		this.noOfStudents = noOfStudents;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getCategory() {
+		return category;
+	}
+
+	public void setCategory(String category) {
+		this.category = category;
+	}
+
+	public int getReviewScore() {
+		return reviewScore;
+	}
+
+	public void setReviewScore(int reviewScore) {
+		this.reviewScore = reviewScore;
+	}
+
+	public int getNoOfStudents() {
+		return noOfStudents;
+	}
+
+	public void setNoOfStudents(int noOfStudents) {
+		this.noOfStudents = noOfStudents;
+	}
+
+	public String toString() {
+		return name + ":" + noOfStudents + ":" + reviewScore;
+	}
+}

Diff for: src/com/ssmtariq/Practice1Exercises.java

@@ -0,0 +1,48 @@
+package com.ssmtariq;
+
+import java.util.List;
+
+public class Practice1Exercises {
+
+	public static void main(String[] args) {
+		List<Integer> numbers = List.of(12,9,7,4,23,7,9);
+		printOddNumberInListFunctional(numbers);
+		printCubesOfOddNumberInListFunctional(numbers);
+		List<String> courses = List.of("Spring", "Spring Boot", "API", "Microservices", "AWS", "PCF", "Azure", "Docker", "Kubernetes");
+		printAllCoursesInListFunctional(courses);
+		printCoursesContainsSpringInListFunctional(courses);
+		printCoursesHavingFourLettersInListFunctional(courses);
+		printCourseLengthsInListFunctional(courses);
+	}
+
+	/*Exercise 1*/
+	private static void printOddNumberInListFunctional(List<Integer> numbers) {
+		numbers.stream().filter(number->number%2!=0).forEach(System.out::println);
+	}
+	
+	/*Exercise 2*/
+	private static void printAllCoursesInListFunctional(List<String> courses) {
+		courses.stream().forEach(System.out::println);
+	}
+
+	/*Exercise 3*/
+	private static void printCoursesContainsSpringInListFunctional(List<String> courses) {
+		courses.stream().filter(course-> course.contains("Spring")).forEach(System.out::println);
+	}
+	
+	/*Exercise 4*/
+	private static void printCoursesHavingFourLettersInListFunctional(List<String> courses) {
+		courses.stream().filter(course->course.length()>4).forEach(System.out::println);
+	}
+
+	/*Exercise 5*/
+	private static void printCubesOfOddNumberInListFunctional(List<Integer> numbers) {
+		numbers.stream().filter(number -> number%2!=0).map(number -> number*number*number).forEach(System.out::println);
+	}
+	
+	/*Exercise 6*/
+	private static void printCourseLengthsInListFunctional(List<String> courses) {
+		courses.stream().map(course -> course +": "+ course.length()).forEach(System.out::println);
+	}
+
+}

Diff for: src/com/ssmtariq/Practice1Functional.java

@@ -0,0 +1,58 @@
+package com.ssmtariq;
+
+import java.util.List;
+
+public class Practice1Functional {
+
+	public static void main(String[] args) {
+		List<Integer> numbers = List.of(12,9,7,4,23,7,9);
+		printAllNumberInListFunctional(numbers);
+		printEvenNumberInListFunctional(numbers);
+		printOddNumberInListFunctional(numbers);
+	}
+
+	public static void print(int number) {
+		System.out.println(number);
+	}
+	
+	private static void printAllNumberInListFunctional(List<Integer> numbers) {
+		//How to loop the numbers
+		//In traditional approach we focus on HOW
+//		for(int number : numbers) {
+//			System.out.println(number);
+//		}
+		
+		//In functional approach we focus on WHAT
+		//What to do
+		numbers.stream().forEach(Practice1Functional::print); //ClassName :: MethodName. This is called method reference
+		
+		//We can avoid using the print() method as below
+		numbers.stream().forEach(System.out::println); //ClassName :: MethodName. This is called method reference
+	}
+	
+	private static boolean isEven(int number) {
+		return number%2==0;
+	}
+	
+	private static void printEvenNumberInListFunctional(List<Integer> numbers) {
+		//What to do
+		numbers.stream()
+		.filter(Practice1Functional::isEven) //Filter: Only allow even numbers
+		.forEach(System.out::println); //ClassName :: MethodName. This is called method reference
+		
+		/**
+		 * Lambda: A lambda is nothing but a method with simple syntax as below
+		 * ARGUMENT -> ACTION;
+		 * Lambda for the method isEven is below
+		 * number -> number%2==0;
+		 */
+		numbers.stream()
+		.filter(number->number%2==0) //Filter: Only allow even numbers
+		.forEach(System.out::println); //ClassName :: MethodName. This is called method reference
+	}
+
+	private static void printOddNumberInListFunctional(List<Integer> numbers) {
+		numbers.stream().filter(number->number%2!=0).forEach(System.out::println);
+	}
+
+}

Diff for: src/com/ssmtariq/Practice1Structured.java

@@ -0,0 +1,27 @@
+package com.ssmtariq;
+
+import java.util.List;
+
+public class Practice1Structured {
+
+	public static void main(String[] args) {
+		List<Integer> numbers = List.of(12,9,7,4,23,7,9);
+		printAllNumberInListStructured(numbers);
+		printEvenNumberInListStructured(numbers);
+	}
+
+	private static void printAllNumberInListStructured(List<Integer> numbers) {
+		//How to loop the numbers
+		//In traditional approach we focus on HOW
+		for(int number : numbers) {
+			System.out.println(number);
+		}
+	}
+
+	private static void printEvenNumberInListStructured(List<Integer> numbers) {
+		for(int number : numbers) {
+			if(number%2==0)System.out.println(number);
+		}
+	}
+
+}

Diff for: src/com/ssmtariq/Practice2Exercises.java

@@ -0,0 +1,29 @@
+package com.ssmtariq;
+
+import java.util.List;
+
+public class Practice2Exercises {
+
+	public static void main(String[] args) {
+//		List<Integer> numbers = List.of(12,9,7,4,23,7,9);
+		List<Integer> numbers = List.of(1,2,3);
+		System.out.println(sumOfSquaresOfAllNumbersInList(numbers));
+		System.out.println(sumOfCubeOfAllNumbersInList(numbers));
+		System.out.println(sumOfOddNumbersInList(numbers));
+	}
+
+	/*Exercise 7*/
+	private static int sumOfSquaresOfAllNumbersInList(List<Integer> numbers) {
+		return numbers.stream().map(number->number*number).reduce(0,Integer::sum);
+	}
+	
+	/*Exercise 8*/
+	private static int sumOfCubeOfAllNumbersInList(List<Integer> numbers) {
+		return numbers.stream().map(number->number*number*number).reduce(0, Integer::sum);
+	}
+
+	/*Exercise 9*/
+	private static int sumOfOddNumbersInList(List<Integer> numbers) {
+		return numbers.stream().filter(number->number%2!=0).reduce(0,Integer::sum);
+	}
+}

Diff for: src/com/ssmtariq/Practice2Functional.java

@@ -0,0 +1,25 @@
+package com.ssmtariq;
+
+import java.util.List;
+
+public class Practice2Functional {
+
+	public static void main(String[] args) {
+		List<Integer> numbers = List.of(12,9,7,4,23,7,9);
+		int sum = addListStructured(numbers);
+		System.out.println(sum);
+	}
+
+	private static int addListStructured(List<Integer> numbers) {
+		//Stream of number -> One result value
+			//Combine them into one result => One value
+			//0 and FP02Functional::sum
+//		return numbers.stream().reduce(0, FP02Functional::sum);
+//		return numbers.stream().reduce(0, (a,b) -> a+b);
+		return numbers.stream().reduce(0, Integer::sum);
+	}
+	
+	private static int sum(int a, int b) {
+		return a+b;
+	}
+}

Diff for: src/com/ssmtariq/Practice2Structured.java

@@ -0,0 +1,20 @@
+package com.ssmtariq;
+
+import java.util.List;
+
+public class Practice2Structured {
+
+	public static void main(String[] args) {
+		List<Integer> numbers = List.of(12,9,7,4,23,7,9);
+		int sum = addListStructured(numbers);
+		System.out.println(sum);
+	}
+
+	private static int addListStructured(List<Integer> numbers) {
+		int sum =0;
+		for(int number : numbers) {
+			sum += number;
+		}
+		return sum;
+	}
+}

Diff for: src/com/ssmtariq/Practice3Exercises.java

@@ -0,0 +1,41 @@
+package com.ssmtariq;
+
+import java.util.List;
+import java.util.function.BinaryOperator;
+import java.util.stream.Collectors;
+
+public class Practice3Exercises {
+
+	public static void main(String[] args) {
+		List<String> courses = List.of("Spring", "Spring Boot", "API", "Microservices", "AWS", "PCF", "Azure", "Docker", "Kubernetes");
+		List<Integer> numbers = List.of(12,9,7,4,23,7,9);
+		System.out.println(subListOfEvenNumbersInListFunctional(numbers));
+		System.out.println(subListOfCourseLengthsInListFunctional(courses));
+		System.out.println(createInterfaceImplAndFindSumInListFunctional(numbers));
+	}
+
+	/*Exercise 10*/
+	private static List<Integer> subListOfEvenNumbersInListFunctional(List<Integer> numbers) {
+		return numbers.stream().filter(n->n%2==0).collect(Collectors.toList());
+	}
+	
+	/*Exercise 11*/
+	private static List<Integer> subListOfCourseLengthsInListFunctional(List<String> courses) {
+		return courses.stream().map(c->c.length()).collect(Collectors.toList());
+	}
+	
+	/*Exercise 12*/
+	private static Integer createInterfaceImplAndFindSumInListFunctional(List<Integer> numbers) {
+//		BinaryOperator<Integer> accumulator = Integer::sum;
+		BinaryOperator<Integer> accumulator2 = new BinaryOperator<Integer>() {
+			
+			@Override
+			public Integer apply(Integer t, Integer u) {
+				return t+u;
+			}
+		};
+//		int sum = numbers.stream().reduce(0, Integer::sum);
+		return numbers.stream().reduce(0, accumulator2);
+	}
+
+}

Diff for: src/com/ssmtariq/Practice3Functional.java

@@ -0,0 +1,41 @@
+package com.ssmtariq;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Practice3Functional {
+
+	public static void main(String[] args) {
+		List<String> courses = List.of("Spring", "Spring Boot", "API", "Microservices", "AWS", "PCF", "Azure", "Docker", "Kubernetes");
+		printAllCoursesSortedByCourseLengthInListFunctional(courses);
+		List<Integer> numbers = List.of(12,9,7,4,23,7,9);
+		printNumbersInListSortedByDesc(numbers);
+		System.out.println(squaresOfNumbersInListFunctional(numbers));
+		System.out.println(subListOfEvenNumbersInListFunctional(numbers));
+		System.out.println(subListOfCourseLengthsInListFunctional(courses));
+	}
+
+	/*Exercise 10*/
+	private static List<Integer> subListOfEvenNumbersInListFunctional(List<Integer> numbers) {
+		return numbers.stream().filter(n->n%2==0).collect(Collectors.toList());
+	}
+	
+	/*Exercise 11*/
+	private static List<Integer> subListOfCourseLengthsInListFunctional(List<String> courses) {
+		return courses.stream().map(c->c.length()).collect(Collectors.toList());
+	}
+
+	private static List<Integer> squaresOfNumbersInListFunctional(List<Integer> numbers) {
+		return numbers.stream().map(n->n*n).collect(Collectors.toList());
+	}
+
+	private static void printNumbersInListSortedByDesc(List<Integer> numbers) {
+		numbers.stream().distinct().sorted(Comparator.reverseOrder()).forEach(System.out::println);		
+	}
+
+	private static void printAllCoursesSortedByCourseLengthInListFunctional(List<String> courses) {
+		courses.stream().sorted(Comparator.comparing(str -> str.length())).forEach(System.out::println);
+	}
+
+}

Diff for: src/com/ssmtariq/Practice4BehaviorParameterization.java

@@ -0,0 +1,20 @@
+package com.ssmtariq;
+
+import java.util.List;
+import java.util.function.Predicate;
+
+public class Practice4BehaviorParameterization {
+	public static void main(String[] args) {
+		List<Integer> numbers = List.of(12,9,7,4,23,7,9);
+		
+		Predicate<Integer> oddPredicate = n->n%2!=0;
+		filterAndPrint(numbers, oddPredicate);
+		
+		Predicate<Integer> evenPredicate = n->n%2==0;
+		filterAndPrint(numbers, evenPredicate);
+	}
+	
+	private static void filterAndPrint(List<Integer> numbers, Predicate<Integer> predicate) {
+		numbers.stream().filter(predicate).forEach(System.out::println);
+	}
+}