Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 15591d0

Browse files
ssmtariqssmtariq
committedJul 23, 2021
Add functional programming practices
0 parents  commit 15591d0

18 files changed

+642
-0
lines changed
 

‎src/com/ssmtariq/Course.java

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
package com.ssmtariq;
2+
3+
class Course {
4+
private String name;
5+
private String category;
6+
private int reviewScore;
7+
private int noOfStudents;
8+
9+
public Course(String name, String category, int reviewScore, int noOfStudents) {
10+
super();
11+
this.name = name;
12+
this.category = category;
13+
this.reviewScore = reviewScore;
14+
this.noOfStudents = noOfStudents;
15+
}
16+
17+
public String getName() {
18+
return name;
19+
}
20+
21+
public void setName(String name) {
22+
this.name = name;
23+
}
24+
25+
public String getCategory() {
26+
return category;
27+
}
28+
29+
public void setCategory(String category) {
30+
this.category = category;
31+
}
32+
33+
public int getReviewScore() {
34+
return reviewScore;
35+
}
36+
37+
public void setReviewScore(int reviewScore) {
38+
this.reviewScore = reviewScore;
39+
}
40+
41+
public int getNoOfStudents() {
42+
return noOfStudents;
43+
}
44+
45+
public void setNoOfStudents(int noOfStudents) {
46+
this.noOfStudents = noOfStudents;
47+
}
48+
49+
public String toString() {
50+
return name + ":" + noOfStudents + ":" + reviewScore;
51+
}
52+
}

‎src/com/ssmtariq/Practice1Exercises.java

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
package com.ssmtariq;
2+
3+
import java.util.List;
4+
5+
public class Practice1Exercises {
6+
7+
public static void main(String[] args) {
8+
List<Integer> numbers = List.of(12,9,7,4,23,7,9);
9+
printOddNumberInListFunctional(numbers);
10+
printCubesOfOddNumberInListFunctional(numbers);
11+
List<String> courses = List.of("Spring", "Spring Boot", "API", "Microservices", "AWS", "PCF", "Azure", "Docker", "Kubernetes");
12+
printAllCoursesInListFunctional(courses);
13+
printCoursesContainsSpringInListFunctional(courses);
14+
printCoursesHavingFourLettersInListFunctional(courses);
15+
printCourseLengthsInListFunctional(courses);
16+
}
17+
18+
/*Exercise 1*/
19+
private static void printOddNumberInListFunctional(List<Integer> numbers) {
20+
numbers.stream().filter(number->number%2!=0).forEach(System.out::println);
21+
}
22+
23+
/*Exercise 2*/
24+
private static void printAllCoursesInListFunctional(List<String> courses) {
25+
courses.stream().forEach(System.out::println);
26+
}
27+
28+
/*Exercise 3*/
29+
private static void printCoursesContainsSpringInListFunctional(List<String> courses) {
30+
courses.stream().filter(course-> course.contains("Spring")).forEach(System.out::println);
31+
}
32+
33+
/*Exercise 4*/
34+
private static void printCoursesHavingFourLettersInListFunctional(List<String> courses) {
35+
courses.stream().filter(course->course.length()>4).forEach(System.out::println);
36+
}
37+
38+
/*Exercise 5*/
39+
private static void printCubesOfOddNumberInListFunctional(List<Integer> numbers) {
40+
numbers.stream().filter(number -> number%2!=0).map(number -> number*number*number).forEach(System.out::println);
41+
}
42+
43+
/*Exercise 6*/
44+
private static void printCourseLengthsInListFunctional(List<String> courses) {
45+
courses.stream().map(course -> course +": "+ course.length()).forEach(System.out::println);
46+
}
47+
48+
}

‎src/com/ssmtariq/Practice1Functional.java

Lines changed: 58 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,58 @@
1+
package com.ssmtariq;
2+
3+
import java.util.List;
4+
5+
public class Practice1Functional {
6+
7+
public static void main(String[] args) {
8+
List<Integer> numbers = List.of(12,9,7,4,23,7,9);
9+
printAllNumberInListFunctional(numbers);
10+
printEvenNumberInListFunctional(numbers);
11+
printOddNumberInListFunctional(numbers);
12+
}
13+
14+
public static void print(int number) {
15+
System.out.println(number);
16+
}
17+
18+
private static void printAllNumberInListFunctional(List<Integer> numbers) {
19+
//How to loop the numbers
20+
//In traditional approach we focus on HOW
21+
// for(int number : numbers) {
22+
// System.out.println(number);
23+
// }
24+
25+
//In functional approach we focus on WHAT
26+
//What to do
27+
numbers.stream().forEach(Practice1Functional::print); //ClassName :: MethodName. This is called method reference
28+
29+
//We can avoid using the print() method as below
30+
numbers.stream().forEach(System.out::println); //ClassName :: MethodName. This is called method reference
31+
}
32+
33+
private static boolean isEven(int number) {
34+
return number%2==0;
35+
}
36+
37+
private static void printEvenNumberInListFunctional(List<Integer> numbers) {
38+
//What to do
39+
numbers.stream()
40+
.filter(Practice1Functional::isEven) //Filter: Only allow even numbers
41+
.forEach(System.out::println); //ClassName :: MethodName. This is called method reference
42+
43+
/**
44+
* Lambda: A lambda is nothing but a method with simple syntax as below
45+
* ARGUMENT -> ACTION;
46+
* Lambda for the method isEven is below
47+
* number -> number%2==0;
48+
*/
49+
numbers.stream()
50+
.filter(number->number%2==0) //Filter: Only allow even numbers
51+
.forEach(System.out::println); //ClassName :: MethodName. This is called method reference
52+
}
53+
54+
private static void printOddNumberInListFunctional(List<Integer> numbers) {
55+
numbers.stream().filter(number->number%2!=0).forEach(System.out::println);
56+
}
57+
58+
}

‎src/com/ssmtariq/Practice1Structured.java

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
package com.ssmtariq;
2+
3+
import java.util.List;
4+
5+
public class Practice1Structured {
6+
7+
public static void main(String[] args) {
8+
List<Integer> numbers = List.of(12,9,7,4,23,7,9);
9+
printAllNumberInListStructured(numbers);
10+
printEvenNumberInListStructured(numbers);
11+
}
12+
13+
private static void printAllNumberInListStructured(List<Integer> numbers) {
14+
//How to loop the numbers
15+
//In traditional approach we focus on HOW
16+
for(int number : numbers) {
17+
System.out.println(number);
18+
}
19+
}
20+
21+
private static void printEvenNumberInListStructured(List<Integer> numbers) {
22+
for(int number : numbers) {
23+
if(number%2==0)System.out.println(number);
24+
}
25+
}
26+
27+
}

‎src/com/ssmtariq/Practice2Exercises.java

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
package com.ssmtariq;
2+
3+
import java.util.List;
4+
5+
public class Practice2Exercises {
6+
7+
public static void main(String[] args) {
8+
// List<Integer> numbers = List.of(12,9,7,4,23,7,9);
9+
List<Integer> numbers = List.of(1,2,3);
10+
System.out.println(sumOfSquaresOfAllNumbersInList(numbers));
11+
System.out.println(sumOfCubeOfAllNumbersInList(numbers));
12+
System.out.println(sumOfOddNumbersInList(numbers));
13+
}
14+
15+
/*Exercise 7*/
16+
private static int sumOfSquaresOfAllNumbersInList(List<Integer> numbers) {
17+
return numbers.stream().map(number->number*number).reduce(0,Integer::sum);
18+
}
19+
20+
/*Exercise 8*/
21+
private static int sumOfCubeOfAllNumbersInList(List<Integer> numbers) {
22+
return numbers.stream().map(number->number*number*number).reduce(0, Integer::sum);
23+
}
24+
25+
/*Exercise 9*/
26+
private static int sumOfOddNumbersInList(List<Integer> numbers) {
27+
return numbers.stream().filter(number->number%2!=0).reduce(0,Integer::sum);
28+
}
29+
}

‎src/com/ssmtariq/Practice2Functional.java

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
package com.ssmtariq;
2+
3+
import java.util.List;
4+
5+
public class Practice2Functional {
6+
7+
public static void main(String[] args) {
8+
List<Integer> numbers = List.of(12,9,7,4,23,7,9);
9+
int sum = addListStructured(numbers);
10+
System.out.println(sum);
11+
}
12+
13+
private static int addListStructured(List<Integer> numbers) {
14+
//Stream of number -> One result value
15+
//Combine them into one result => One value
16+
//0 and FP02Functional::sum
17+
// return numbers.stream().reduce(0, FP02Functional::sum);
18+
// return numbers.stream().reduce(0, (a,b) -> a+b);
19+
return numbers.stream().reduce(0, Integer::sum);
20+
}
21+
22+
private static int sum(int a, int b) {
23+
return a+b;
24+
}
25+
}

‎src/com/ssmtariq/Practice2Structured.java

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
package com.ssmtariq;
2+
3+
import java.util.List;
4+
5+
public class Practice2Structured {
6+
7+
public static void main(String[] args) {
8+
List<Integer> numbers = List.of(12,9,7,4,23,7,9);
9+
int sum = addListStructured(numbers);
10+
System.out.println(sum);
11+
}
12+
13+
private static int addListStructured(List<Integer> numbers) {
14+
int sum =0;
15+
for(int number : numbers) {
16+
sum += number;
17+
}
18+
return sum;
19+
}
20+
}

‎src/com/ssmtariq/Practice3Exercises.java

Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,41 @@
1+
package com.ssmtariq;
2+
3+
import java.util.List;
4+
import java.util.function.BinaryOperator;
5+
import java.util.stream.Collectors;
6+
7+
public class Practice3Exercises {
8+
9+
public static void main(String[] args) {
10+
List<String> courses = List.of("Spring", "Spring Boot", "API", "Microservices", "AWS", "PCF", "Azure", "Docker", "Kubernetes");
11+
List<Integer> numbers = List.of(12,9,7,4,23,7,9);
12+
System.out.println(subListOfEvenNumbersInListFunctional(numbers));
13+
System.out.println(subListOfCourseLengthsInListFunctional(courses));
14+
System.out.println(createInterfaceImplAndFindSumInListFunctional(numbers));
15+
}
16+
17+
/*Exercise 10*/
18+
private static List<Integer> subListOfEvenNumbersInListFunctional(List<Integer> numbers) {
19+
return numbers.stream().filter(n->n%2==0).collect(Collectors.toList());
20+
}
21+
22+
/*Exercise 11*/
23+
private static List<Integer> subListOfCourseLengthsInListFunctional(List<String> courses) {
24+
return courses.stream().map(c->c.length()).collect(Collectors.toList());
25+
}
26+
27+
/*Exercise 12*/
28+
private static Integer createInterfaceImplAndFindSumInListFunctional(List<Integer> numbers) {
29+
// BinaryOperator<Integer> accumulator = Integer::sum;
30+
BinaryOperator<Integer> accumulator2 = new BinaryOperator<Integer>() {
31+
32+
@Override
33+
public Integer apply(Integer t, Integer u) {
34+
return t+u;
35+
}
36+
};
37+
// int sum = numbers.stream().reduce(0, Integer::sum);
38+
return numbers.stream().reduce(0, accumulator2);
39+
}
40+
41+
}

‎src/com/ssmtariq/Practice3Functional.java

Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,41 @@
1+
package com.ssmtariq;
2+
3+
import java.util.Comparator;
4+
import java.util.List;
5+
import java.util.stream.Collectors;
6+
7+
public class Practice3Functional {
8+
9+
public static void main(String[] args) {
10+
List<String> courses = List.of("Spring", "Spring Boot", "API", "Microservices", "AWS", "PCF", "Azure", "Docker", "Kubernetes");
11+
printAllCoursesSortedByCourseLengthInListFunctional(courses);
12+
List<Integer> numbers = List.of(12,9,7,4,23,7,9);
13+
printNumbersInListSortedByDesc(numbers);
14+
System.out.println(squaresOfNumbersInListFunctional(numbers));
15+
System.out.println(subListOfEvenNumbersInListFunctional(numbers));
16+
System.out.println(subListOfCourseLengthsInListFunctional(courses));
17+
}
18+
19+
/*Exercise 10*/
20+
private static List<Integer> subListOfEvenNumbersInListFunctional(List<Integer> numbers) {
21+
return numbers.stream().filter(n->n%2==0).collect(Collectors.toList());
22+
}
23+
24+
/*Exercise 11*/
25+
private static List<Integer> subListOfCourseLengthsInListFunctional(List<String> courses) {
26+
return courses.stream().map(c->c.length()).collect(Collectors.toList());
27+
}
28+
29+
private static List<Integer> squaresOfNumbersInListFunctional(List<Integer> numbers) {
30+
return numbers.stream().map(n->n*n).collect(Collectors.toList());
31+
}
32+
33+
private static void printNumbersInListSortedByDesc(List<Integer> numbers) {
34+
numbers.stream().distinct().sorted(Comparator.reverseOrder()).forEach(System.out::println);
35+
}
36+
37+
private static void printAllCoursesSortedByCourseLengthInListFunctional(List<String> courses) {
38+
courses.stream().sorted(Comparator.comparing(str -> str.length())).forEach(System.out::println);
39+
}
40+
41+
}

‎src/com/ssmtariq/Practice4BehaviorParameterization.java

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
package com.ssmtariq;
2+
3+
import java.util.List;
4+
import java.util.function.Predicate;
5+
6+
public class Practice4BehaviorParameterization {
7+
public static void main(String[] args) {
8+
List<Integer> numbers = List.of(12,9,7,4,23,7,9);
9+
10+
Predicate<Integer> oddPredicate = n->n%2!=0;
11+
filterAndPrint(numbers, oddPredicate);
12+
13+
Predicate<Integer> evenPredicate = n->n%2==0;
14+
filterAndPrint(numbers, evenPredicate);
15+
}
16+
17+
private static void filterAndPrint(List<Integer> numbers, Predicate<Integer> predicate) {
18+
numbers.stream().filter(predicate).forEach(System.out::println);
19+
}
20+
}

‎src/com/ssmtariq/Practice4CustomClass.java

Lines changed: 123 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
1+
package com.ssmtariq;
2+
3+
import java.util.Arrays;
4+
import java.util.Comparator;
5+
import java.util.List;
6+
import java.util.function.Predicate;
7+
import java.util.stream.Collectors;
8+
9+
public class Practice4CustomClass {
10+
11+
public static void main(String[] args) {
12+
List<Course> courses = List.of(
13+
new Course("Spring", "Framework", 98, 20000),
14+
new Course("Spring Boot", "Framework", 95, 18000),
15+
new Course("API", "Microservices", 97, 22000),
16+
new Course("Microservices", "Microservices", 96, 25000),
17+
new Course("FullStack", "FullStack", 91, 14000),
18+
new Course("AWS", "Cloud", 92, 21000),
19+
new Course("Azure", "Cloud", 99, 21000),
20+
new Course("Docker", "Cloud", 92, 20000),
21+
new Course("Kubernetes", "Cloud", 91, 20000)
22+
);
23+
//allMatch, noneMatch, anyMatch
24+
Predicate<Course> reviewScoreGreaterThan90 = course->course.getReviewScore()>90;
25+
System.out.println(courses.stream().allMatch(reviewScoreGreaterThan90));
26+
27+
Predicate<Course> reviewScoreLessThan90 = getPredicateForReviewScoreLessThan90();
28+
System.out.println(courses.stream().noneMatch(reviewScoreLessThan90));
29+
30+
Predicate<Course> reviewScoreGreaterThan97 = course->course.getReviewScore()>99;
31+
System.out.println(courses.stream().anyMatch(reviewScoreGreaterThan97));
32+
33+
Comparator<Course> comparingNumberOfStudentsIncreasing = Comparator.comparing(Course::getNoOfStudents);
34+
System.out.println(courses.stream().sorted(comparingNumberOfStudentsIncreasing).collect(Collectors.toList()));
35+
36+
Comparator<Course> comparingNumberOfStudentsDecreasing = Comparator.comparing(Course::getNoOfStudents).reversed();
37+
System.out.println(courses.stream().sorted(comparingNumberOfStudentsDecreasing).collect(Collectors.toList()));
38+
39+
/*thenComparing: AND operation*/
40+
Comparator<Course> comparingNumberOfStudentsAndReviewScoresDecreasing = Comparator.comparing(Course::getNoOfStudents).thenComparing(Course::getReviewScore).reversed();
41+
System.out.println(courses.stream().sorted(comparingNumberOfStudentsAndReviewScoresDecreasing).collect(Collectors.toList()));
42+
43+
/*skip*/
44+
System.out.println(courses.stream().sorted(Comparator.comparing(Course::getName)).skip(3).collect(Collectors.toList()));
45+
46+
/*limit*/
47+
System.out.println(courses.stream().sorted(Comparator.comparing(Course::getName)).skip(3).limit(2).collect(Collectors.toList()));
48+
49+
/*takeWhile*/
50+
System.out.println(courses.stream().sorted(Comparator.comparing(Course::getName)).takeWhile(course->course.getName().length()<=9).collect(Collectors.toList()));
51+
52+
/*dropWhile*/
53+
System.out.println(courses.stream().sorted(Comparator.comparing(Course::getName)).dropWhile(course->course.getName().length()<=9).collect(Collectors.toList()));
54+
55+
/*max*/
56+
System.out.println(courses.stream().max(Comparator.comparing(Course::getName).reversed()).orElse(new Course("AWS", "Cloud", 92, 21000)));
57+
58+
/*min*/
59+
System.out.println(courses.stream().min(Comparator.comparing(Course::getName).reversed()).orElse(new Course("AWS", "Cloud", 92, 21000)));
60+
61+
/*optional*/
62+
System.out.println(courses.stream().filter(c->c.getName().length()>15).min(Comparator.comparing(Course::getName)).orElse(new Course("AWS", "Cloud", 92, 21000)));
63+
64+
/*findFirst*/
65+
System.out.println(courses.stream().filter(c->c.getName().length()>9).findFirst().orElse(new Course("AWS", "Cloud", 92, 21000)));
66+
67+
/*findAny*/
68+
System.out.println(courses.stream().filter(c->c.getName().length()>11).sorted(Comparator.comparing(Course::getNoOfStudents).reversed()).findAny().orElse(new Course("AWS", "Cloud", 92, 21000)));
69+
70+
/*sum*/
71+
System.out.println(courses.stream().filter(c->c.getReviewScore()>95).mapToInt(Course::getNoOfStudents).sum());
72+
73+
/*average*/
74+
System.out.println(courses.stream().filter(c->c.getReviewScore()>95).mapToInt(Course::getNoOfStudents).average());
75+
76+
/*count*/
77+
System.out.println(courses.stream().filter(c->c.getReviewScore()>95).mapToInt(Course::getNoOfStudents).count());
78+
79+
/*max & min*/
80+
System.out.println(courses.stream().filter(c->c.getReviewScore()>95).mapToInt(Course::getNoOfStudents).max());
81+
System.out.println(courses.stream().filter(c->c.getReviewScore()>95).mapToInt(Course::getNoOfStudents).min());
82+
83+
/*groupBy category*/
84+
System.out.println(courses.stream().collect(Collectors.groupingBy(Course::getCategory)));
85+
86+
/*groupBy category count*/
87+
System.out.println(courses.stream().collect(Collectors.groupingBy(Course::getCategory, Collectors.counting())));
88+
89+
/*groupBy category max*/
90+
System.out.println(courses.stream().collect(Collectors.groupingBy(Course::getCategory, Collectors.maxBy(Comparator.comparing(Course::getReviewScore)))));
91+
92+
/*groupBy category name only*/
93+
System.out.println(courses.stream()
94+
.collect(
95+
Collectors.groupingBy(
96+
Course::getCategory,
97+
Collectors.mapping(Course::getName, Collectors.toList())
98+
)
99+
)
100+
);
101+
/*joining*/
102+
System.out.println(courses.stream().map(s->s.getName()).collect(Collectors.joining(",")));
103+
104+
/*joining-split-characters*/
105+
System.out.println(courses.stream().map(s->s.getName().split("")).collect(Collectors.toList()));
106+
System.out.println(courses.stream().map(s->s.getName().split("")).flatMap(Arrays::stream).collect(Collectors.toList()));
107+
System.out.println(courses.stream().map(s->s.getName().split("")).flatMap(Arrays::stream).distinct().collect(Collectors.toList()));
108+
109+
/*joining-advance*/
110+
System.out.println(courses.stream().flatMap(course1->courses.stream().map(course2->List.of(course1.getName(), course2.getName()))).collect(Collectors.toList()));
111+
System.out.println(
112+
courses.stream()
113+
.flatMap(course1->courses.stream().map(course2->List.of(course1.getName(), course2.getName())))
114+
.filter(list->!list.get(0).equals(list.get(1)))
115+
.collect(Collectors.toList())
116+
);
117+
}
118+
119+
public static Predicate<Course> getPredicateForReviewScoreLessThan90(){
120+
return course->course.getReviewScore()<90;
121+
}
122+
123+
}

‎src/com/ssmtariq/Practice4Exercises.java

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
package com.ssmtariq;
2+
3+
import java.util.List;
4+
import java.util.function.Function;
5+
import java.util.stream.Collectors;
6+
7+
public class Practice4Exercises {
8+
9+
public static void main(String[] args) {
10+
List<Integer> numbers = List.of(12,9,7,4,23,7,9);
11+
System.out.println(subListOfSquaredNumbersInListFunctional(numbers, n->n*n));
12+
13+
System.out.println(numbers.stream().reduce(0, Integer::sum));
14+
}
15+
16+
/*Exercise 13*/
17+
private static List<Integer> subListOfSquaredNumbersInListFunctional(List<Integer> numbers, Function<Integer, Integer> function) {
18+
return numbers.stream().map(function).collect(Collectors.toList());
19+
}
20+
21+
}

‎src/com/ssmtariq/Practice4Functional.java

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
package com.ssmtariq;
2+
3+
import java.math.BigInteger;
4+
import java.util.Arrays;
5+
import java.util.List;
6+
import java.util.stream.Collectors;
7+
import java.util.stream.IntStream;
8+
9+
public class Practice4Functional {
10+
11+
public static void main(String[] args) {
12+
List<Integer> numbers = List.of(12,9,7,4,23,7,9);
13+
System.out.println(numbers.stream().reduce(0, Integer::sum));
14+
15+
int[] array = {12,9,7,4,23,7,9};
16+
System.out.println(Arrays.stream(array).sum());
17+
18+
System.out.println(IntStream.range(1, 10).sum());
19+
System.out.println(IntStream.rangeClosed(1, 10).sum());
20+
21+
System.out.println(IntStream.iterate(1, e->e+2).limit(10).peek(System.out::println).sum());
22+
System.out.println(IntStream.iterate(1, e->e+2).limit(10).boxed().collect(Collectors.toList()));
23+
24+
System.out.println(IntStream.rangeClosed(1, 5).reduce(0, Integer::sum));
25+
26+
/*Big Number Calculation*/
27+
System.out.println(IntStream.rangeClosed(1, 50).mapToObj(BigInteger::valueOf).reduce(BigInteger.ONE, BigInteger::add));
28+
System.out.println(IntStream.rangeClosed(1, 50).mapToObj(BigInteger::valueOf).reduce(BigInteger.ONE, BigInteger::multiply));
29+
}
30+
31+
}

‎src/com/ssmtariq/Practice4MethodReferences.java

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
package com.ssmtariq;
2+
3+
import java.util.Comparator;
4+
import java.util.List;
5+
6+
public class Practice4MethodReferences {
7+
8+
public static void main(String[] args) {
9+
List<String> courses = List.of("Spring", "Spring Boot", "API", "Microservices", "AWS", "PCF", "Azure", "Docker", "Kubernetes");
10+
courses.stream().sorted(Comparator.comparing(x -> x.length())).map(String::toUpperCase).forEach(System.out::println);
11+
}
12+
}

‎src/com/ssmtariq/Practice5Files.java

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
package com.ssmtariq;
2+
3+
import java.io.IOException;
4+
import java.nio.file.Files;
5+
import java.nio.file.Paths;
6+
import java.util.Arrays;
7+
8+
public class Practice5Files {
9+
10+
public static void main(String[] args) throws IOException {
11+
Files.lines(Paths.get("test.txt"))
12+
.map(s->s.split(" "))
13+
.flatMap(Arrays::stream)
14+
.distinct().sorted()
15+
.forEach(System.out::println);
16+
17+
Files.list(Paths.get("."))
18+
.filter(Files::isDirectory)
19+
.forEach(System.out::println);
20+
}
21+
22+
}

‎src/com/ssmtariq/Practice5Functional.java

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
package com.ssmtariq;
2+
3+
import java.util.ArrayList;
4+
import java.util.List;
5+
6+
public class Practice5Functional {
7+
8+
public static void main(String[] args) {
9+
List<Course> courses = List.of(
10+
new Course("Spring", "Framework", 98, 20000),
11+
new Course("Spring Boot", "Framework", 95, 18000),
12+
new Course("API", "Microservices", 97, 22000),
13+
new Course("Microservices", "Microservices", 96, 25000),
14+
new Course("FullStack", "FullStack", 91, 14000),
15+
new Course("AWS", "Cloud", 92, 21000),
16+
new Course("Azure", "Cloud", 99, 21000),
17+
new Course("Docker", "Cloud", 92, 20000),
18+
new Course("Kubernetes", "Cloud", 91, 20000)
19+
);
20+
21+
System.out.println(courses.stream().filter(c->c.getName().length()>11).map(c->c.getName().toUpperCase()).findFirst());
22+
23+
List<String> courseList = List.of("Spring", "Spring Boot", "API", "Microservices", "AWS", "PCF", "Azure", "Docker", "Kubernetes");
24+
25+
/*remove all*/
26+
List<String> modifiableList = new ArrayList<>(courseList);
27+
modifiableList.replaceAll(s->s.toUpperCase());
28+
System.out.println(modifiableList);
29+
30+
/*remove if*/
31+
modifiableList.removeIf(c->c.length()<6);
32+
System.out.println(modifiableList);
33+
}
34+
35+
}

‎src/com/ssmtariq/Practice5Threads.java

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
package com.ssmtariq;
2+
3+
import java.util.stream.IntStream;
4+
5+
public class Practice5Threads {
6+
7+
public static void main(String[] args) {
8+
Runnable runnable = new Runnable() {
9+
10+
@Override
11+
public void run() {
12+
for(int i=0; i<1000; i++) {
13+
// System.out.println(Thread.currentThread().getId()+" : "+i);
14+
}
15+
}
16+
};
17+
18+
Thread thread = new Thread(runnable);
19+
thread.start();
20+
21+
Thread thread1 = new Thread(runnable);
22+
thread1.start();
23+
24+
Thread thread2 = new Thread(runnable);
25+
thread2.start();
26+
27+
Runnable runnable2 = ()->{
28+
IntStream.range(0, 10000).forEach(i->System.out.println(Thread.currentThread().getId()+":"+i));
29+
};
30+
Thread thread3 = new Thread(runnable2);
31+
thread3.start();
32+
}
33+
34+
}

‎test.txt

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,3 @@
1+
Hi
2+
This text is from the file
3+
Thanks for using this file

0 commit comments

Comments
 (0)
Please sign in to comment.