diff --git a/modern-java8/gradle.properties b/modern-java8/gradle.properties index 265dd32..4afa434 100644 --- a/modern-java8/gradle.properties +++ b/modern-java8/gradle.properties @@ -8,4 +8,4 @@ lombookVersion=1.18.20 assertJVersion=3.19.0 #Constant for projects, all below are for plugins version and build -javaVersion=11 \ No newline at end of file +javaVersion=17.0.1 \ No newline at end of file diff --git a/modern-java8/src/main/java/com/pratap/comparision/Main.java b/modern-java8/src/main/java/com/pratap/comparision/Main.java index fa746c4..7ba2920 100644 --- a/modern-java8/src/main/java/com/pratap/comparision/Main.java +++ b/modern-java8/src/main/java/com/pratap/comparision/Main.java @@ -20,7 +20,7 @@ public static void main(String[] args) { Comparator brandComparator = (l1, l2) -> { return l1.getBrand().compareTo(l2.getBrand()); }; - Collections.sort(laptops, brandComparator); - laptops.stream().forEach(System.out::println); + laptops.sort(brandComparator); + laptops.forEach(System.out::println); } } diff --git a/modern-java8/src/main/java/com/pratap/java/inheritance/InheritanceTest01.java b/modern-java8/src/main/java/com/pratap/java/inheritance/InheritanceTest01.java new file mode 100644 index 0000000..dbf6b6c --- /dev/null +++ b/modern-java8/src/main/java/com/pratap/java/inheritance/InheritanceTest01.java @@ -0,0 +1,41 @@ +package com.pratap.java.inheritance; +class Parent{ + + public String name = "parent-name"; + + public void m1(){ + System.out.println("Parent()"); + } +} + +class Child extends Parent{ + + public String name = "child-name"; +// Child class has two methods m1() & m2 + public void m2(){ + System.out.println("Child()"); + } +} +public class InheritanceTest01 { + + public static void main(String[] args) { + //case - 1 + Parent parent = new Parent(); + parent.m1(); + System.out.println("name : "+parent.name); +// parent.m2(); // Compilation Error + //case - 2 + Child child = new Child(); + child.m1(); + child.m2(); + System.out.println("name : "+child.name); + //case - 3 + Parent parent1 = new Child();//Polymorphism + parent1.m1(); + System.out.println("name : "+parent1.name); + //parent1.m2();//CE + + //case - 4 + // Child child1 = new Parent(); //CE + } +} diff --git a/modern-java8/src/main/java/com/pratap/java8/stream/StreamsLimitSkipExample.java b/modern-java8/src/main/java/com/pratap/java8/stream/StreamsLimitSkipExample.java index 8515d11..80eae87 100644 --- a/modern-java8/src/main/java/com/pratap/java8/stream/StreamsLimitSkipExample.java +++ b/modern-java8/src/main/java/com/pratap/java8/stream/StreamsLimitSkipExample.java @@ -4,6 +4,10 @@ import java.util.List; import java.util.Optional; +/** + * Stream API - limit() & skip() + * helps to create a sub stream + */ public class StreamsLimitSkipExample { public static Optional limit(List nums){ diff --git a/modern-java8/src/main/java/com/pratap/java8/stream/numeric/NumericStreamExample.java b/modern-java8/src/main/java/com/pratap/java8/stream/terminal/NumericStreamExample.java similarity index 72% rename from modern-java8/src/main/java/com/pratap/java8/stream/numeric/NumericStreamExample.java rename to modern-java8/src/main/java/com/pratap/java8/stream/terminal/NumericStreamExample.java index 3c8a16c..20fbd0e 100644 --- a/modern-java8/src/main/java/com/pratap/java8/stream/numeric/NumericStreamExample.java +++ b/modern-java8/src/main/java/com/pratap/java8/stream/terminal/NumericStreamExample.java @@ -1,9 +1,16 @@ -package com.pratap.java8.stream.numeric; +package com.pratap.java8.stream.terminal; import java.util.Arrays; import java.util.List; import java.util.stream.IntStream; +/** + * Stream API - reduce() + * Terminal operation, used to reduce the contents of stream to a single value + * It takes two parameters as input + * 1st parameter - default or initial value + * 2nd parameter - BinaryOperator + */ public class NumericStreamExample { public static int sumOfNNumbers(List integerList) { diff --git a/modern-java8/src/main/java/com/pratap/java8/stream/terminal/StreamCountingExample.java b/modern-java8/src/main/java/com/pratap/java8/stream/terminal/StreamCountingExample.java index b99ddb6..4757aed 100644 --- a/modern-java8/src/main/java/com/pratap/java8/stream/terminal/StreamCountingExample.java +++ b/modern-java8/src/main/java/com/pratap/java8/stream/terminal/StreamCountingExample.java @@ -9,8 +9,7 @@ public class StreamCountingExample { public static long count() { return StudentDataBase.getAllStudents() .stream() - .filter(student -> student.getGpa() >= 3.9) - .collect(counting()); + .filter(student -> student.getGpa() >= 3.9).count(); } public static void main(String[] args) { diff --git a/modern-java8/src/test/java/com/pratap/comparision/LaptopComparisionTest.java b/modern-java8/src/test/java/com/pratap/java/comparision/LaptopComparisionTest.java similarity index 94% rename from modern-java8/src/test/java/com/pratap/comparision/LaptopComparisionTest.java rename to modern-java8/src/test/java/com/pratap/java/comparision/LaptopComparisionTest.java index 47eaa27..09edad6 100644 --- a/modern-java8/src/test/java/com/pratap/comparision/LaptopComparisionTest.java +++ b/modern-java8/src/test/java/com/pratap/java/comparision/LaptopComparisionTest.java @@ -1,5 +1,6 @@ -package com.pratap.comparision; +package com.pratap.java.comparision; +import com.pratap.comparision.Laptop; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/modern-java8/src/test/java/com/pratap/java8/stream/operations/FindFirstAndFindAnyTest.java b/modern-java8/src/test/java/com/pratap/java8/stream/operations/FindFirstAndFindAnyTest.java new file mode 100644 index 0000000..a23d20b --- /dev/null +++ b/modern-java8/src/test/java/com/pratap/java8/stream/operations/FindFirstAndFindAnyTest.java @@ -0,0 +1,76 @@ +package com.pratap.java8.stream.operations; + +import com.pratap.java8.beans.Student; +import com.pratap.java8.mockdata.StudentDataBase; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Stream API - findFirst() & findAny() + * used to find an element in a the stream + * both the functions return the result of type Optional + * findFirst() - returns the first element in the stream + * findAny() - returns the first encountered element in the context of parallel stream. + * findAny() behave same as findFirst() in the context of sequential stream + */ +public class FindFirstAndFindAnyTest { + + private List students; + + @BeforeEach + void setup(){ + students = StudentDataBase.getAllStudents(); + } + + @Test + void testFindAnyStudentWRTSequentialStream(){ + Optional result = students.stream() + .filter(student -> student.getGpa() > 3.8) + .findAny(); + + assertTrue(result.isPresent()); + assertThat(result.get()) + .extracting(student -> student.getName().equals("Emily")); + } + + @Test + void testFindAnyStudentWRTParallelStream(){ + Optional result = students.stream().parallel() + .filter(student -> student.getGpa() > 3.8) + .findAny(); + + assertTrue(result.isPresent()); + assertThat(result.get()) + .extracting(student -> student.getName()) + .isIn("Emily", "Dave", "James"); + } + + @Test + void testFindFirstStudentWRTSequentialStream(){ + Optional result = students.stream() + .filter(student -> student.getGpa() > 3.8) + .findFirst(); + + assertTrue(result.isPresent()); + assertThat(result.get()) + .extracting(student -> student.getName().equals("Emily")); + } + + @Test + void testFindFirstStudentWRTParallelStream(){ + Optional result = students.stream() + .parallel() + .filter(student -> student.getGpa() > 3.8) + .findFirst(); + + assertTrue(result.isPresent()); + assertThat(result.get()) + .extracting(student -> student.getName().equals("Emily")); + } +} diff --git a/modern-java8/src/test/java/com/pratap/java8/stream/operations/StreamMatchTest.java b/modern-java8/src/test/java/com/pratap/java8/stream/operations/StreamMatchTest.java new file mode 100644 index 0000000..0d45ed1 --- /dev/null +++ b/modern-java8/src/test/java/com/pratap/java8/stream/operations/StreamMatchTest.java @@ -0,0 +1,55 @@ +package com.pratap.java8.stream.operations; + +import com.pratap.java8.beans.Student; +import com.pratap.java8.mockdata.StudentDataBase; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Stream API - anyMatch(), allMatch() & noneMatch() + * All these functions takes in a Predicate as an input and returns a Boolean as an output + */ +public class StreamMatchTest { + + List students; + + @BeforeEach + void setup(){ + students = StudentDataBase.getAllStudents(); + } + + @Test + void testAllMatch(){ + assertTrue(students.stream().allMatch(student -> student.getGpa() >= 3.5)); + } + + @Test + void testAllMatchNegative(){ + assertFalse(students.stream().allMatch(student -> student.getGpa() >= 4.0)); + } + + @Test + void testAnyMatch(){ + assertTrue(students.stream().anyMatch(student -> student.getGpa() >= 3.9)); + } + + @Test + void testAnyMatchNegative(){ + assertFalse(students.stream().anyMatch(student -> student.getGpa() >= 5.9)); + } + + @Test + void testNoneMatch(){ + assertTrue(students.stream().noneMatch(student -> student.getGpa() == 5.9)); + } + + @Test + void testNoneMatchNegative(){ + assertFalse(students.stream().noneMatch(student -> student.getGpa() == 3.6)); + } +} diff --git a/modern-java8/src/test/java/com/pratap/java8/stream/practice/RepeatedAndNonRepeatedCharFindTest.java b/modern-java8/src/test/java/com/pratap/java8/stream/practice/RepeatedAndNonRepeatedCharFindTest.java new file mode 100644 index 0000000..2f240b4 --- /dev/null +++ b/modern-java8/src/test/java/com/pratap/java8/stream/practice/RepeatedAndNonRepeatedCharFindTest.java @@ -0,0 +1,56 @@ +package com.pratap.java8.stream.practice; + +import org.junit.jupiter.api.Test; + +import java.util.LinkedHashMap; +import java.util.function.Function; +import java.util.stream.Collectors; + +import static java.util.stream.Collectors.counting; +import static java.util.stream.Collectors.groupingBy; +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class RepeatedAndNonRepeatedCharFindTest { + + private char getFirstNonRepeatedChar(String input){ + + return input.chars() + .mapToObj(num -> Character.toLowerCase(Character.valueOf((char) num))) + .collect(groupingBy(Function.identity(), LinkedHashMap::new, counting())) + .entrySet() + .stream() + .filter(entry -> entry.getValue() == 1L) + .map(entry -> entry.getKey()) + .findFirst() + .get(); + + } + + private char getFirstRepeatedChar(String input){ + + return input.chars() + .mapToObj(num -> Character.toLowerCase(Character.valueOf((char) num))) + .collect(groupingBy(Function.identity(), LinkedHashMap::new, counting())) + .entrySet() + .stream() + .filter(entry -> entry.getValue() > 1L) + .map(entry -> entry.getKey()) + .findFirst() + .get(); + + } + + @Test + void testGetFirstNonRepeatedChar(){ + String inputStr = "Hello"; + char result = getFirstNonRepeatedChar(inputStr); + assertEquals('h', result); + } + + @Test + void testGetFirstRepeatedChar(){ + String inputStr = "Hello"; + char result = getFirstRepeatedChar(inputStr); + assertEquals('l', result); + } +} diff --git a/modern-java8/src/test/java/com/pratap/java8/stream/practice/TwoStringsAreSameCharsTest.java b/modern-java8/src/test/java/com/pratap/java8/stream/practice/TwoStringsAreSameCharsTest.java index f5813bc..829a5bd 100644 --- a/modern-java8/src/test/java/com/pratap/java8/stream/practice/TwoStringsAreSameCharsTest.java +++ b/modern-java8/src/test/java/com/pratap/java8/stream/practice/TwoStringsAreSameCharsTest.java @@ -1,11 +1,39 @@ package com.pratap.java8.stream.practice; -import java.util.Arrays; -import java.util.List; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.function.Function; + +import static java.util.stream.Collectors.counting; +import static java.util.stream.Collectors.groupingBy; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class TwoStringsAreSameCharsTest { - private void compareTwoStringChars(String str1, String str2){ - List strings = Arrays.asList(str1, str2); + private boolean compareTwoStringChars(String str1, String str2){ + + HashMap hashMapOne = str1.chars() + .mapToObj(num -> Character.toLowerCase(Character.valueOf((char) num))) + .collect(groupingBy(Function.identity(), HashMap::new, counting())); + + HashMap hashMapTwo = str2.chars() + .mapToObj(num -> Character.toLowerCase(Character.valueOf((char) num))) + .collect(groupingBy(Function.identity(), HashMap::new, counting())); + + return hashMapOne.entrySet().stream() + .allMatch(entry -> entry.getValue().equals(hashMapTwo.get(entry.getKey()))); + } + + @Test + void testCompareTwoStringChars(){ + + assertTrue(compareTwoStringChars("aabbccdee", "aaccbbeed")); + } + + @Test + void testCompareTwoStringCharsWithDiffString(){ + assertFalse(compareTwoStringChars("aabbccdeeee", "aaccbbeed")); } }