diff --git a/pom.xml b/pom.xml index 2f7dd97..2706957 100644 --- a/pom.xml +++ b/pom.xml @@ -5,23 +5,31 @@ org.springframework.boot spring-boot-starter-parent - 2.6.2 + 3.3.2 com.practice - JavaProblems + JavaAssessments 0.1 - JavaProblems + Java_Assessment 21 + + org.springframework.boot + spring-boot-starter-security + + + org.springframework.boot + spring-boot-starter-web + - com.oracle.database.jdbc - ojdbc10 - 19.3.0.0 + io.jsonwebtoken + jjwt + 0.9.1 @@ -31,27 +39,39 @@ org.springframework.boot - spring-boot-starter-log4j2 + spring-boot-starter-web + + org.projectlombok + lombok + true + - - - - - + + com.mysql + mysql-connector-j + 9.3.0 + + + com.oracle.database.jdbc + ojdbc10 + 19.3.0.0 + + + + org.springframework.boot + spring-boot-starter-log4j2 + + junit junit 4.13.1 test - - mysql - mysql-connector-java - @@ -71,6 +91,13 @@ 3.9 + + + com.h2database + h2 + runtime + + @@ -83,4 +110,4 @@ - \ No newline at end of file + diff --git a/src/main/java/com/advanceJava/ConsumerSupplierPredicates.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/ConsumerSupplierPredicates.java similarity index 96% rename from src/main/java/com/advanceJava/ConsumerSupplierPredicates.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/ConsumerSupplierPredicates.java index 4ef237f..585a093 100644 --- a/src/main/java/com/advanceJava/ConsumerSupplierPredicates.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/ConsumerSupplierPredicates.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; import java.util.function.Consumer; diff --git a/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/FunctionalInterface1.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/FunctionalInterface1.java new file mode 100644 index 0000000..5b5b8ee --- /dev/null +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/FunctionalInterface1.java @@ -0,0 +1,47 @@ +package com.Java8StreamLambdaFuncInterfaceMethodRef; + +interface aI { + public int func(String a, String b); + + // It can have default func + default int func(String a) { + return a.length(); + } +} + +/* + * Step 1 : Do not implement interface + * Step 2 : Call interface name with return type aI(a) = + * Step 3 : take args (a , b ) + * Step 4 : defination of that absratct method + * Step 5 : call that method + */ + +interface bI { + public int operation(int a, int b); +} + + +public class FunctionalInterface1 { + public static void main(String[] args) { + + /* Both are same ainterface and ainterface2 */ + aI ainterface = (b, c) -> { + return b.length() + c.length(); + }; + + aI ainterface2 = (b, c) -> b.length() + c.length(); + + int count = ainterface.func("abc", "xyz"); + int count2 = ainterface2.func("abcd", "wxyz"); + + System.out.println(count); + System.out.println(count2); + + /* ************ */ + + bI add = (l, m) -> l + m; + bI mul = (l, m) -> l * m; + + } +} diff --git a/src/main/java/com/advanceJava/Java8Features.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/Java8Features.java similarity index 98% rename from src/main/java/com/advanceJava/Java8Features.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/Java8Features.java index 098e5cf..6a56bfe 100644 --- a/src/main/java/com/advanceJava/Java8Features.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/Java8Features.java @@ -1,4 +1,6 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; + +import com.advanceJava.CollectionUtils; import java.util.Iterator; import java.util.Optional; @@ -154,7 +156,7 @@ public static void main(String[] args) { */ class ForEachExample { public static void main(String[] args) { - CollectionUtils.sampleList().forEach(System.out::println); + CollectionUtils.sampleList().forEach(System.out::println); System.out.println("ForEachExample.main()"); CollectionUtils.sampleList().forEach(smple -> System.out.println(smple)); diff --git a/src/main/java/com/coreJava/Java8Predicates.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/Java8Predicates.java similarity index 94% rename from src/main/java/com/coreJava/Java8Predicates.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/Java8Predicates.java index 5fe6d96..8b17370 100644 --- a/src/main/java/com/coreJava/Java8Predicates.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/Java8Predicates.java @@ -1,4 +1,4 @@ -package com.coreJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; import java.util.List; import java.util.function.Predicate; diff --git a/src/main/java/com/advanceJava/LambdaExpression1.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression1.java similarity index 94% rename from src/main/java/com/advanceJava/LambdaExpression1.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression1.java index 0bfe1d4..8567289 100755 --- a/src/main/java/com/advanceJava/LambdaExpression1.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression1.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; /* It provides a clear and concise way to represent one method interface using an expression. It is very useful in collection library. diff --git a/src/main/java/com/advanceJava/LambdaExpression2.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression2.java similarity index 90% rename from src/main/java/com/advanceJava/LambdaExpression2.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression2.java index fad0abe..88f8d19 100755 --- a/src/main/java/com/advanceJava/LambdaExpression2.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression2.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; /** * here methodBody of FuncInterface is in lambda Expression diff --git a/src/main/java/com/advanceJava/LambdaExpression3.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression3.java similarity index 86% rename from src/main/java/com/advanceJava/LambdaExpression3.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression3.java index 2f97aeb..dc035ed 100755 --- a/src/main/java/com/advanceJava/LambdaExpression3.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression3.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; interface FuncIntrWithMultParam{ int add (int a , int b ); diff --git a/src/main/java/com/advanceJava/LambdaExpression4.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression4.java similarity index 91% rename from src/main/java/com/advanceJava/LambdaExpression4.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression4.java index e2906aa..439e4e0 100755 --- a/src/main/java/com/advanceJava/LambdaExpression4.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression4.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; import java.util.*; diff --git a/src/main/java/com/advanceJava/LambdaExpression5.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression5.java similarity index 91% rename from src/main/java/com/advanceJava/LambdaExpression5.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression5.java index 5b29f6f..22ae173 100755 --- a/src/main/java/com/advanceJava/LambdaExpression5.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression5.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; public class LambdaExpression5 { diff --git a/src/main/java/com/advanceJava/LambdaExpression7.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression7.java similarity index 93% rename from src/main/java/com/advanceJava/LambdaExpression7.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression7.java index a0e85e1..de0aac9 100755 --- a/src/main/java/com/advanceJava/LambdaExpression7.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression7.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; import java.util.ArrayList; diff --git a/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression8.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression8.java new file mode 100644 index 0000000..40388ce --- /dev/null +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/LambdaExpression8.java @@ -0,0 +1,214 @@ +package com.Java8StreamLambdaFuncInterfaceMethodRef; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; + +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +@Data +@Builder +@AllArgsConstructor +class Person { + String name; + int age; +} + +public class LambdaExpression8 { + + public static void main(String[] args) { + new LambdaExpression8().sortMethod(); + + add2List(); + reverseList(); + reverseString(); + } + + private static void add2List() { + + List l1 = new java.util.ArrayList<>(); + l1.add("A"); + l1.add("B"); // We can not use List..of() bcause it is immutable and can use addAll on that + List l2 = List.of("v", "x"); + List l3 = Stream.builder().add(l1).add(l2).build().toList();// [[a, b], [v, x]] + + var l4 = Stream.concat(l1.stream(), l2.stream()).toList(); // [a, b, v, x] + System.out.println(l3); + System.out.println(l4); + l1.addAll(l2); + System.out.println(l1); + } + + private void sortMethod() { + List words = List.of("apple", "banana", "kiwi"); + List sortedWords = words.stream() + .sorted(Comparator.comparing(String::length)) // + + .sorted(String::compareTo) + .sorted(testMethod()) + .collect(Collectors.toList()); + System.out.println("Sorted Words by Length: " + sortedWords); + } + + // Note Wrapper class have compareTo method + private Comparator testMethod() { + return String::compareTo; + } + + private static void reverseList() { + } + + private static void reverseString() { + String app = "apple"; + + app.chars() + .mapToObj(c -> String.valueOf((char) c)) // This step is imp + .reduce("", (a, b) -> b + a) + .toString(); + + String input = "hello"; + String reversed = + input.chars() + .mapToObj(c -> String.valueOf((char) c)) + .reduce("", (a, b) -> b + a); + System.out.println("Reversed String: " + reversed); + + // sum of digit + String a = "1234"; + + var s = a.chars() + .mapToObj(c -> ((char) c)) + .map(Character::getNumericValue) + .reduce(0, (a1, b1) -> a1 + b1); + + List wordList = List.of("apple", "banana", "kiwi", "abcd", "abcde", "banana"); + wordList.stream() + .sorted(Comparator.comparing(String::length)) + .sorted(Comparator.reverseOrder()) + .findFirst() + .ifPresent(System.out::println); + + + wordList.stream() + .max(Comparator.comparing(String::length)) + .ifPresent(System.out::println); + + + Map> grouped = wordList.stream() + .collect(Collectors.groupingBy(Function.identity())); // it means x -> x // mostly used in map where we provide key as x only + // / toMap(x->x , x->x + + Map> grouped1 = wordList.stream() + .collect(Collectors.groupingBy(x -> x)); + + + System.out.println("Grouped Words: " + grouped); + + + var a1 = wordList.stream().collect(Collectors.groupingBy(String::length)); + System.out.println(a1); + + List list = List.of( + new Person("Alice", 25), + new Person("Bob", 30), + new Person("Charlie", 25)); + + var v = list.stream() + .collect(Collectors.groupingBy(Person::getName)); + System.out.println(v); + + List list1 = List.of(1, 2, 3, 4); + List list2 = List.of(3, 4, 5, 6); + + var p1 = list1.stream() + .filter(u -> list2.contains(u)) // ! + .toList(); + System.out.println(p1); + + // 37. Count Occurrences/counts of Each Vowel in String // "apple" + var aaa = app.chars() + .mapToObj(c -> (char) c) + .filter(c1 -> "aeiou".contains(c1.toString())) //.filter(Character::isDigit) to filter only charasters + .collect(Collectors.groupingBy(cg -> cg, Collectors.counting())); + + System.out.println(aaa); + + // Reverse a List Using Streams + System.out.println(wordList.reversed().stream().toList()); + + //40. Reverse a String Using Streams + String revers = new StringBuilder("hello").reverse().toString(); + + +// String reversed1 = Stream.of(input.split("")) +// .collect(Collectors.collectingAndThen(Collectors.toList(), +// list -> { +// Collections.reverse(list); +// return String.join("", list); +// }));System.out.println(reversed1); + +// + String reversed1 = input.chars() + .mapToObj(c -> String.valueOf((char) c)) + .reduce("", (a2, b2) -> b2 + a2); + System.out.println("Reversed String: " + reversed); + + //41. Find the Most Frequent Element in List + input.chars() + .mapToObj(c -> ((char) c)) + // .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); + .collect(Collectors.groupingBy(f -> f, Collectors.counting())) + .entrySet() + .stream() + .max(Map.Entry.comparingByValue()) + .map(Map.Entry::getKey) + .orElse(null); + + + // Check if a String is a Palindrome NAMAN + String inp = "madam"; + boolean isPalindrome = IntStream.range(0, inp.length() / 2) + .allMatch(i -> inp.charAt(i) == inp.charAt(inp.length() - 1 - i)); + + System.out.println( + "abcdaabbccc".chars().mapToObj(c -> (char) c).collect(Collectors.groupingBy(x -> x, Collectors.counting()))); + + + // 47. Generate the Fibonacci Sequence Using Streams + IntStream.range(0,10) + .reduce( 1, (aaaa,bbbb)-> aaaa*bbbb ) + ; + + // 52. Find the Longest Palindrome in a List of Strings + +//54. Find the Longest Word in a String + + + //58. Find the Number of Characters in a File + //59. Find the Number of Words in a File + + + //61. Process a CSV File and Calculate Aggregate Statistics + +// Reverse String 1. chars . mapToObj ( String.valueOf ) ,reduce( "",(a,b)-> b+a) + var sss = "sachin".chars() + .mapToObj(c -> String.valueOf((char) c)) + .reduce("", (s1, s2) -> s2 + s1); + System.out.println("----" + sss); + + + int arr[] = {1, 35, 7, 9, 6}; + ArrayList l1 = new ArrayList( 3); + List l = Arrays.asList(arr); + + + } +} + + +//Reverse a String Using Streams + diff --git a/src/main/java/com/advanceJava/MethodRefrence1.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence1.java similarity index 94% rename from src/main/java/com/advanceJava/MethodRefrence1.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence1.java index 42da5fe..4da0607 100755 --- a/src/main/java/com/advanceJava/MethodRefrence1.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence1.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; /* used to refer method of functional interface. alternate of lambda expression diff --git a/src/main/java/com/advanceJava/MethodRefrence2.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence2.java similarity index 93% rename from src/main/java/com/advanceJava/MethodRefrence2.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence2.java index b4c2a2f..b0739ef 100755 --- a/src/main/java/com/advanceJava/MethodRefrence2.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence2.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; /** Runnable interface contains only one abstract method. diff --git a/src/main/java/com/advanceJava/MethodRefrence3.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence3.java similarity index 96% rename from src/main/java/com/advanceJava/MethodRefrence3.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence3.java index 7fd44c6..9e576ab 100755 --- a/src/main/java/com/advanceJava/MethodRefrence3.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence3.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; // we override static methods by referring methods. // In the following example, we have defined and overloaded three add methods. diff --git a/src/main/java/com/advanceJava/MethodRefrence4.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence4.java similarity index 93% rename from src/main/java/com/advanceJava/MethodRefrence4.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence4.java index a3234cb..4c2c6fd 100755 --- a/src/main/java/com/advanceJava/MethodRefrence4.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence4.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; /** * diff --git a/src/main/java/com/advanceJava/MethodRefrence5.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence5.java similarity index 87% rename from src/main/java/com/advanceJava/MethodRefrence5.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence5.java index ea3a9b2..8ba0bca 100755 --- a/src/main/java/com/advanceJava/MethodRefrence5.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/MethodRefrence5.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; interface Messageable1{ Message1 getMessage(String msg); diff --git a/src/main/java/com/advanceJava/StreamApi0.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi0.java similarity index 97% rename from src/main/java/com/advanceJava/StreamApi0.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi0.java index 341f7ef..5e31d7f 100644 --- a/src/main/java/com/advanceJava/StreamApi0.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi0.java @@ -1,4 +1,5 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; + import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/com/advanceJava/StreamApi1.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi1.java similarity index 90% rename from src/main/java/com/advanceJava/StreamApi1.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi1.java index 70d983e..814b21c 100755 --- a/src/main/java/com/advanceJava/StreamApi1.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi1.java @@ -1,4 +1,6 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; + +import com.Java8StreamLambdaFuncInterfaceMethodRef._1Java8Features; import java.util.ArrayList; import java.util.List; diff --git a/src/main/java/com/advanceJava/StreamApi2.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi2.java similarity index 90% rename from src/main/java/com/advanceJava/StreamApi2.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi2.java index e86d2e8..50e7ff0 100644 --- a/src/main/java/com/advanceJava/StreamApi2.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi2.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; import java.util.stream.*; diff --git a/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi3.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi3.java new file mode 100644 index 0000000..9b49700 --- /dev/null +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi3.java @@ -0,0 +1,86 @@ +package com.Java8StreamLambdaFuncInterfaceMethodRef; + +import lombok.AllArgsConstructor; +import lombok.Data; + +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +// Iterating With Stream Api With Reduce +/* Reduce() takes a sequence of input elements +and combines them into a single summary result + by repeated operation. */ + +public class StreamApi3 { + + public static void main(String[] args) { + List list = new LinkedList<>(); + list.add(new Studs(4, "Sachin", "Phy", 50)); + list.add(new Studs(2, "Rahul", "Chem", 53)); + list.add(new Studs(1, "Amita", "Arts", 22)); + list.add(new Studs(3, "Yatin", "Math", 73)); + list.add(new Studs(4, "Puneet", "Eco", 14)); + list.add(new Studs(6, "Pooja", "Mech", 82)); + list.add(new Studs(8, "Manish", "Comp", 12)); + + + System.out.println("Count Where Marks > 50 " + + list.stream() + .filter(p -> p.marks > 50) + .count()); + // Via Collectors list.stream().collect(Collectors.counting()); + System.out.println("Sum Where " + + list.stream() + .map(p -> p.marks) + .reduce(0, Integer::sum)); + System.out.println("Total Sum marks Via Collectors " + + list.stream() + .collect(Collectors.summingInt(x -> x.marks))); + + System.out.println("Sum For > 50 " + + list.stream() + .filter(p -> p.marks > 50) + .map(p -> p.marks) // use ( Studs :: getMarks) ie. method refrence + // though Studs should have getMarks() + .reduce(0, Integer::sum)); + + System.out.println(" Max marks " + + list.stream() + .max((p1, p2) -> (p1.marks - p2.marks)) + .get().marks); + + System.out.println(" Min marks " + + list.stream() + .min((p1, p2) -> (p1.marks - p2.marks)) + .get().marks); + + System.out.println(" Iterate "); + + Map nameRollMap = list.stream() + .collect(Collectors.toMap(p -> p.name, p -> p.roll)); + + Stream.Builder> builder = Stream.builder(); + Stream> stream = builder.add(nameRollMap).build(); + System.out.println(" Getting Map Name , Roll"); + stream.forEach(System.out::println); + + System.out.println(" Getting Map Values Via Stream"); + + Stream.builder().add(nameRollMap) + .build().forEach(System.out::println); + // .forEach( map -> System.out.println(map.name)); + + } +} + +@Data +@AllArgsConstructor +class Studs { + int roll; + String name; + String dept; + int marks; +} \ No newline at end of file diff --git a/src/main/java/com/advanceJava/StreamApi4.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi4.java similarity index 94% rename from src/main/java/com/advanceJava/StreamApi4.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi4.java index 5b38141..14b3f77 100644 --- a/src/main/java/com/advanceJava/StreamApi4.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi4.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; import java.util.List; diff --git a/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi5.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi5.java new file mode 100644 index 0000000..cef92e9 --- /dev/null +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApi5.java @@ -0,0 +1,77 @@ +package com.Java8StreamLambdaFuncInterfaceMethodRef; + +import lombok.AllArgsConstructor; +import lombok.Data; + +import java.util.List; +import java.util.stream.Stream; + +@Data +@AllArgsConstructor +class Studentz { + public int id; + public String name; + public int age; + + public String getName() { + return name; + } + + public int getAge() { + return age; + } +} + + +public class StreamApi5 { + public static void main(String[] args) { + Stream streamGenerated = + Stream.generate(() -> "element").limit(5); + + streamGenerated.forEach(System.out::println); + + mapMethod(); + flatMapMethod1(); + flatMapMethod2(); + + } + + private static void flatMapMethod1() { + var studentz = new Studentz(1, "Maverick", 18); + var studentz2 = new Studentz(2, "Sam", 28); + var studentz3 = new Studentz(3, "Sampy", 38); + var studentz4 = new Studentz(4, "Sampo", 15); + var studentz5 = new Studentz(5, "Sahil", 25); + + List l1 = List.of(studentz, studentz2); + List l2 = List.of(studentz3, studentz4, studentz5); + + List> l3 = List.of(l1, l2); + l3.forEach(System.out::println); + System.out.println("Formatted** "); + // var l4 = + l3.stream() + .flatMap(l -> l.stream() + .map(s -> s.name)) + .forEach(System.out::println); + + + l3.stream() + .flatMap(l -> l.stream() + .map(s -> s.name)) + .max(String::compareTo) + ; + + + // System.out.println(l4); + + + } + + private static void mapMethod() { + } + + private static void flatMapMethod2() { + } + +} diff --git a/src/main/java/com/advanceJava/StreamApiExamples1.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApiExamples1.java similarity index 56% rename from src/main/java/com/advanceJava/StreamApiExamples1.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApiExamples1.java index 8b1c1a7..96bb696 100644 --- a/src/main/java/com/advanceJava/StreamApiExamples1.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StreamApiExamples1.java @@ -1,10 +1,6 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; +import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -13,10 +9,8 @@ public class StreamApiExamples1 { public static void main(String[] args) { System.out.println("3 Power of 8 ie 8*8*8 : " + (int) Math.pow(8, 3)); printEvenNums(); - System.out.println("Getting Duplicates"); findDuplicateinList(); - } static void findDuplicateinList() { @@ -34,24 +28,24 @@ static void findDuplicateinList() { System.out.println(map); map.entrySet().stream() - .filter(en -> en.getValue() > 1) - .forEach(System.out::print); + .filter(en -> en.getValue() > 1) + .forEach(System.out::print); //2 Another Way :: By Stream() and Set - var set = new HashSet(); + var set = new HashSet(); list.stream() - .filter(n -> !set.add(n) ) // Elements which are not entered in Set as Set dont allow duplicates + .filter(n -> !set.add(n)) // Elements which are not entered in Set as Set dont allow duplicates .forEach(System.out::print); - // 3. BY Collections.frequency + // 3. BY Collections.frequency - System.out.println(""); + System.out.println(""); - System.out.println("Getting Duplicates BY Collection.Frequency"); + System.out.println("Getting Duplicates BY Collection.Frequency"); - list.stream() - .filter(n -> Collections.frequency(list, n) > 1 ) // Elements which are not entered in Set as Set dont allow duplicates - .collect(Collectors.toSet()); + list.stream() + .filter(n -> Collections.frequency(list, n) > 1) // Elements which are not entered in Set as Set dont allow duplicates + .collect(Collectors.toSet()); } @@ -63,10 +57,10 @@ static void printEvenNums() { System.out.println(""); // merge all those lists to create a single list , It can have duplicates Stream.of( - Arrays.asList("Asia", "India", "Paks", "Nepal", "Liberia", "Mali", "Mauritius"), - Arrays.asList("Colombia", "Finland", "Greece", "Iceland", "Liberia", "Mali", "Mauritius"), - Arrays.asList("Peru", "Serbia", "Singapore", "Turkey", "Uzbekistan", "Yemen", "Zimbabwe", "Greece", - "Iceland")) + Arrays.asList("Asia", "India", "Paks", "Nepal", "Liberia", "Mali", "Mauritius"), + Arrays.asList("Colombia", "Finland", "Greece", "Iceland", "Liberia", "Mali", "Mauritius"), + Arrays.asList("Peru", "Serbia", "Singapore", "Turkey", "Uzbekistan", "Yemen", "Zimbabwe", "Greece", + "Iceland")) .flatMap(List::stream) .forEach(System.out::print); System.out.println(""); diff --git a/src/main/java/com/advanceJava/StringJoiner1.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StringJoiner1.java similarity index 96% rename from src/main/java/com/advanceJava/StringJoiner1.java rename to src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StringJoiner1.java index b87ebc4..b340f5f 100755 --- a/src/main/java/com/advanceJava/StringJoiner1.java +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/StringJoiner1.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.Java8StreamLambdaFuncInterfaceMethodRef; import java.util.StringJoiner; diff --git a/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/_1Java8Features.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/_1Java8Features.java new file mode 100644 index 0000000..ec08bd6 --- /dev/null +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/_1Java8Features.java @@ -0,0 +1,125 @@ +package com.Java8StreamLambdaFuncInterfaceMethodRef; + + +import java.util.LinkedList; +import java.util.List; + +// Lambda expressions, +public class _1Java8Features { + + //Functional interfaces + /*Single Abstract Method */ + + +// Supplier, Consumer, predicate , Function + + + /*Lambda expressions */ + // () -> + + // Method references, + + //Default methods, + + // Static methods in interface + + //Optional class + + //ForEach() method, + + //Stream API + + //Collectors class, + + + //Parallel Array Sorting + + //Concurrency Enhancements + + // JDBC Enhancements + + //Security Enhancements + + // Memory Enhancements Garbage Collectors + + // Date Time Api + + //String Joiner + public static List getStudentList() { + List list = new LinkedList<>(); + list.add(new Student(4, "Sachin", "Phy", 50)); + list.add(new Student(2, "Rahul", "Chem", 53)); + list.add(new Student(1, "Amita", "Arts", 22)); + list.add(new Student(3, "Yatin", "Math", 73)); + list.add(new Student(4, "Puneet", "Eco", 14)); + list.add(new Student(6, "Pooja", "Arts", 82)); + list.add(new Student(8, "Manish", "Math", 12)); + return list; + } + +} + +record Student(int roll, + String name, + String dept, + int marks) {} + + +class Book { + int id; + String name, author, publisher; + int quantity; + + public Book(int id, String name, String author, String publisher, int quantity) { + this.id = id; + this.name = name; + this.author = author; + this.publisher = publisher; + this.quantity = quantity; + } +} + +class Product { + int id; + String name; + float price; + + public Product(int id, String name, float price) { + this.id = id; + this.name = name; + this.price = price; + } +} +/* +* Stream Api +* parellelstream +* of +* builder +* empty() +* generate +* +* map,mapToDouble,mapToInt +* filter +* flatmap +* distinct +* limit +* sorted(Comparator) +* skip +* +* +* count +* max/min +* forEach +* forEachOrdered +* reduce +* collect +* anyMatch +* allMatch +* noneMatch +* findAny +* findFirst +* +* */ + +/*state vs stateless +* */ \ No newline at end of file diff --git a/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/javaCollectors1.java b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/javaCollectors1.java new file mode 100644 index 0000000..b82cb65 --- /dev/null +++ b/src/main/java/com/Java8StreamLambdaFuncInterfaceMethodRef/javaCollectors1.java @@ -0,0 +1,75 @@ +package com.Java8StreamLambdaFuncInterfaceMethodRef; + +import lombok.AllArgsConstructor; +import lombok.Data; + +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.TreeSet; +import java.util.stream.Collectors; + +@Data +@AllArgsConstructor +class Teacher { + public int roll; + public String name; + public String dept; + public int marks; +} + +public class javaCollectors1 { + + public static List getTeacherList() { + List list = new LinkedList<>(); + list.add(new Teacher(4, "Sachin", "Phy", 50)); + list.add(new Teacher(2, "Rahul", "Chem", 53)); + list.add(new Teacher(1, "Amita", "Arts", 22)); + list.add(new Teacher(3, "Yatin", "Math", 73)); + list.add(new Teacher(4, "Puneet", "Eco", 14)); + list.add(new Teacher(6, "Pooja", "Arts", 82)); + list.add(new Teacher(8, "Manish", "Math", 12)); + return list; + } + + static List list = List.of("one", "two", "three", "four", "five", "six", "seven", "eight", "nine"); + + public static void main(String[] args) { + var collect1 = list.stream().collect(Collectors.toMap(key -> key, String::length)); + // var collect2 = list.stream().collect(Collectors.toMap(String::length, key -> key)); // It will give error as it can have duolicate keys + var collect3 = list.stream().collect(Collectors.toMap(String::length, key -> key, (key1, key2) -> key2)); + var collect4 = list.stream().collect(Collectors.toMap(String::length, key -> key, (key1, key2) -> key1 + ":" + key2)); + + System.out.println(collect1); + // System.out.println(collect2); + System.out.println(collect3); + System.out.println(collect4); + + var collect5 = list.stream().collect(Collectors.toCollection(TreeSet::new)); //toMap(key -> key, String::length + System.out.println(collect5); + + list.stream().collect(Collectors.joining(":", "{", "}")); + System.out.println("*******"); + + + // var collect6 = list.stream().collect(Collectors.toCollection( HashMap::new )); //toMap(key -> key, String::length + + Map> collect = getTeacherList().stream() + .collect(Collectors.groupingBy(Teacher::getDept)); + + + System.out.println(collect); + collect.entrySet().stream(); + + + // partitioned by + // Java always partitions a stream into 2 groups based on a predicate — meaning a function that returns true or false. + // the key in the resulting Map is always a Boolean (true or false). + // + //Partioned + //grouping by + + // + + } +} diff --git a/src/main/java/com/TestClass.java b/src/main/java/com/TestClass.java new file mode 100644 index 0000000..87a0201 --- /dev/null +++ b/src/main/java/com/TestClass.java @@ -0,0 +1,104 @@ +//package com; +// +//import jakarta.transaction.Transactional; +//import org.springframework.context.annotation.Bean; +//import org.springframework.context.annotation.Configuration; +// +//import java.util.HashSet; +//import java.util.List; +//import java.util.stream.Stream; +// +//@FunctionalInterface +//interface BiPredicate { +// boolean predict(Integer a, Integer b); +//} +// +//@FunctionalInterface +//interface BiConsumer { +// boolean consume(Integer a, Integer b); +//} +// +// +//public class TestClass { +// +// +// BiPredicate p = (Integer a, Integer b) -> a + b == 9; +// +// public static void main(String[] args) { +// +// int t = 9; +//// var list = List.of(1, 2, 5, 7); +// +// List list = Stream.of(1, 2, 5, 7, 8, 15) +// .sorted() +// .filter(n -> n < t) +// .toList(); +// +// // list.stream(). +// +//// / list.stream() +//// stream.filter(l -> l < 10) +//// .sorted() +//// .forEachOrdered((i, j) -> { +//// +//// }) +//// .reduce() +//// .forEach() +// +// +// HashSet hashSet = new HashSet(); +// hashSet.add("A"); +// hashSet.add("B"); +// hashSet.add("A"); +// +// hashSet.forEach(System.out::println); +// +//// BiPredicate predicate = (a, b) -> a+b; +//// // Find the sum of any two number equals to target in array. {1, 2, 5, 7}, t=9 -> true +//// +//// Predicate predicate = (a, b) -> {a+b ==9}; +//// +//// +//// int t=9; +//// var list = List.of(1, 2, 5, 7); +//// list.stream().filter(l -> l<10) +//// .reduce() +//// .forEach(System.out::println) +// +//// java Stream api +//// SAM +//// -> +//// +//// 21 +//// switch () ->{ +// +// } +// +// } +//} +// +//// virtual thread +//// count down latch +// +//@Transactional +// +//@Configuration +// +//@Bean +//// Profiling +//// dev ,lab . prof +//// Table - Date +// +//// select * from table_name order by created_on desc ; +//// table emps : id name dept +////cont no of emp in each dept +// +//// select dept, count(name) from emps group by dept; +// +//// api1 api2 api3 api4 up / up desc ; serivce zuul +//// zuul discovery +//// microserv +//// +//// circuit braker : any service is down ( call back ) +//// load ba +// diff --git a/src/main/java/com/advanceJava/CollectionUtils.java b/src/main/java/com/advanceJava/CollectionUtils.java index fc54aa0..83056e0 100644 --- a/src/main/java/com/advanceJava/CollectionUtils.java +++ b/src/main/java/com/advanceJava/CollectionUtils.java @@ -14,7 +14,12 @@ public class CollectionUtils { * These methods are useful to create small number of collection. */ public static List sampleList() { - List list = List.of("Java", "JavaFX", "Spring", "Hibernate", "JSP" , "Spring" , "JSP", "Spring", "JDBC"); + List list = List.of("Java", "JavaFX", "Spring", "Hibernate", "JSP", "Spring", "JSP", "Spring", "JDBC"); + return list; + } + + public static List sampleIntList() { + List list = List.of(1, 3, 9, 8, 5, 7, 3, 6, 8, 0); return list; } @@ -31,11 +36,10 @@ public static List getStudentList() { list.add(new Student(4, "Puneet", "Eco", 14)); list.add(new Student(6, "Pooja", "Mech", 82)); list.add(new Student(8, "Manish", "Comp", 12)); - return list; } - public static Map getBookMap() { + public static Map getBookMap() { Map map = new HashMap(); map.put(1, new Book(101, "Let us C", "Yashwant Kanetkar", "BPB", 80)); @@ -72,13 +76,18 @@ public static int[] getIntArray() { int[] a = { 72, 11, 44, 19, 43, 46, 37, 99, 26, 81, 35, 14, 64, 33, 63 }; return a; } + + public static int[] getShortIntArray() { + int[] a = { 5, 4, 7, 2, 1, 3 }; + return a; + } } class Student { - int roll; - String name; - String dept; - int marks; + public int roll; + public String name; + public String dept; + public int marks; public Student(int roll, String name, String dept, int marks) { this.roll = roll; @@ -114,10 +123,10 @@ class Product { int id; String name; float price; - + public Product(int id, String name, float price) { - this.id = id; - this.name = name; - this.price = price; + this.id = id; + this.name = name; + this.price = price; } - } \ No newline at end of file +} \ No newline at end of file diff --git a/src/main/java/com/advanceJava/CompletableFuture1.java b/src/main/java/com/advanceJava/CompletableFuture1.java new file mode 100644 index 0000000..d1b8d75 --- /dev/null +++ b/src/main/java/com/advanceJava/CompletableFuture1.java @@ -0,0 +1,18 @@ +package com.advanceJava; + +import java.util.concurrent.CompletableFuture; + +public class CompletableFuture1 { + public static void main(String[] args) { + + // supplyAsync Takes supplier means it return something + CompletableFuture.supplyAsync(() -> { + try { + Thread.sleep(8000); + } catch (Exception e) { + } + System.out.println("Executed task"); + return "Hello World"; + }); + } +} diff --git a/src/main/java/com/advanceJava/LambdaExpression8.java b/src/main/java/com/advanceJava/LambdaExpression8.java deleted file mode 100644 index 06baf32..0000000 --- a/src/main/java/com/advanceJava/LambdaExpression8.java +++ /dev/null @@ -1,12 +0,0 @@ -package com.advanceJava; - - - -public class LambdaExpression8 { - - public static void main(String[] args) { - - } - - -} diff --git a/src/main/java/com/advanceJava/RecordImplTestClass.java b/src/main/java/com/advanceJava/RecordImplTestClass.java new file mode 100644 index 0000000..e69de29 diff --git a/src/main/java/com/advanceJava/StreamApi3.java b/src/main/java/com/advanceJava/StreamApi3.java deleted file mode 100644 index 729e0be..0000000 --- a/src/main/java/com/advanceJava/StreamApi3.java +++ /dev/null @@ -1,66 +0,0 @@ -package com.advanceJava; - - -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -// Iterating With Stream Api With Reduce -/* Reduce() takes a sequence of input elements -and combines them into a single summary result - by repeated operation. */ - -public class StreamApi3 { - public static void main(String[] args) { - System.out.println("Hello "); - List list = CollectionUtils.getStudentList(); - - System.out.println("Count Where Marks > 50 " + - list.stream() - .filter(p -> p.marks > 50) - .count()); - // Via Collectors list.stream().collect(Collectors.counting()); - System.out.println("Sum Where " + - list.stream() - .map(p -> p.marks) - .reduce(0, Integer::sum)); - System.out.println("Total Sum marks Via Collectors " + - list.stream() - .collect(Collectors.summingInt(x -> x.marks))); - - System.out.println("Sum For > 50 " + - list.stream() - .filter(p -> p.marks > 50) - .map(p -> p.marks) // use (Student :: getMarks) ie. method refrence - // though Student should have getMarks() - .reduce(0, Integer::sum)); - - System.out.println(" Max marks " + - list.stream() - .max((p1, p2) -> (p1.marks - p2.marks)) - .get().marks); - - System.out.println(" Min marks " + - list.stream() - .min((p1, p2) -> (p1.marks - p2.marks)) - .get().marks); - - System.out.println(" Iterate "); - - Map nameRollMap = list.stream() - .collect(Collectors.toMap(p -> p.name, p -> p.roll)); - - Stream.Builder> builder = Stream.builder(); - Stream> stream = builder.add(nameRollMap).build(); - System.out.println(" Getting Map Name , Roll"); - stream.forEach(System.out::println); - - System.out.println(" Getting Map Values Via Stream"); - - Stream.builder().add(nameRollMap) - .build().forEach(System.out::println); - // .forEach( map -> System.out.println(map.name)); - - } -} diff --git a/src/main/java/com/advanceJava/_1Java8Features.java b/src/main/java/com/advanceJava/_1Java8Features.java deleted file mode 100644 index 37a3333..0000000 --- a/src/main/java/com/advanceJava/_1Java8Features.java +++ /dev/null @@ -1,47 +0,0 @@ -package com.advanceJava; - - -// Lambda expressions, -public class _1Java8Features { - - //Functional interfaces - /*Single Abstract Method */ - - -// Supplier, Consumer, predicate , Function - - - /*Lambda expressions */ - // () -> - - // Method references, - - //Default methods, - - // Static methods in interface - - //Optional class - - //ForEach() method, - - //Stream API - - //Collectors class, - - - //Parallel Array Sorting - - //Concurrency Enhancements - - // JDBC Enhancements - - //Security Enhancements - - // Memory Enhancements Garbage Collectors - - // Date Time Api - - //String Joiner - - -} diff --git a/src/main/java/com/collection/CollectionFeatures.java b/src/main/java/com/collection/CollectionFeatures.java new file mode 100644 index 0000000..5ce49a0 --- /dev/null +++ b/src/main/java/com/collection/CollectionFeatures.java @@ -0,0 +1,198 @@ +package com.collection; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.LinkedList; +import java.util.List; +import java.util.TreeSet; +import java.util.stream.Collector; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import lombok.AllArgsConstructor; +import lombok.Data; +import oracle.net.aso.c; + +public class CollectionFeatures { + public static void main(String[] args) { + concurrentException(); + collectorFeatures(); + + } + + private static void concurrentException() { + List list1 = List.of(3, 5, 8, 9); // It returns immutable list , so we cannot change it + // list1.add(6); // We cannot modify it + + List ll = Arrays.asList(1, 4, 6, 9); + List list = new ArrayList<>(Arrays.asList(1, 4, 6, 9)); // it is mutalbe list + list.add(5); + + // for (int i : list) { + // list.add(i); + // } + // you're modifying the list while iterating over it. + + List list2 = List.of(2, 4, 6, 9); + + // for (int i : list) { + // list.add(i); + // } + + // you're modifying the list while iterating over it. + } + + private static void collectorFeatures() { + + Emp e1 = new Emp("hr", "sachin", 9); + Emp e2 = new Emp("hr", "amit", 6); + Emp e3 = new Emp("sale", "yatin", 3); + Emp e4 = new Emp("mech", "vijay", 6); + Emp e5 = new Emp("sale", "abc", 2); + Emp e6 = new Emp("mech", "pnt", 4); + // var l1 = List.of("aa", "bbb", "cccc", "ddddd", "aa", "bbb", "aa", "bbb", + // "cccc"); + var l2 = List.of(5, 7, 3, 4, 8, 5, 1, 7, 5, 9, 8); + var l3 = List.of(e1, e2, e3, e4, e5, e6); + + l2.stream().max(Integer::compareTo); + + // var tmp1 = l1.stream().collect(Collectors.groupingBy(String::length)); // x + // -> x, + + Collectors.mapping(Emp::getSalary, Collectors.toList()); + + var tmp2 = l3.stream().collect(Collectors.groupingBy(Emp::getDept, Collectors.counting())); + var tmp4 = l3.stream() + .collect(Collectors.groupingBy(Emp::getDept, Collectors.maxBy(Comparator.comparing(Emp::getSalary)))); + + System.out.println(tmp4); + + Collectors.summingInt(Emp::getSalary); + + // Collectors.toCollection(LinkedList :: new); + + l3.stream().collect(Collectors.partitioningBy(e -> e.getSalary() > 5000)); + + l3.stream().collect(Collectors.groupingBy(Emp::getDept)); + + var tt = l3.stream().collect(Collectors.groupingBy(Emp::getDept)); + + // Collectors.partitioningBy(e -> e.get); + System.out.println("****"); + System.out.println(tt); + + var tt1 = l3.stream().collect(Collectors.groupingBy(Emp::getDept, Collectors.summingInt(Emp::getSalary))); + System.out.println(tt1); + + var tt2 = l3.stream().collect(Collectors.groupingBy(Emp::getDept, Collectors.summingInt(Emp::getSalary))); + + // get max length string ,, get no of aa , bb , // sort // sort 2nd list + // get + var l1 = List.of("aa", "bbb", "cccc", "ddddd", "aa", "bbb", "aa", "bbb", "cccc"); + + var t4 = l1.stream().max(Comparator.comparing(String::length)); + System.out.println(t4); + + var t5 = l1.stream().collect(Collectors.groupingBy(x -> x, Collectors.counting())); + System.out.println(t5); + + var t6 = l2.stream().sorted(Comparator.reverseOrder()).toList(); + System.out.println(t6); + + // Collections.sort(l1, Comparator.comparing(String::length)); + + // Collections.sort(l3, Comparator.comparing(Emp::getSalary)); l3 is immutable + // Collections.sort(l3, Comparator.comparing(Emp::getDept)); l3 is immutable + + // e Product of All Elements in a List + + System.out.println(l2.stream().reduce(1, (a, b) -> a * b)); + + // + System.out.println(l2.stream().collect(Collectors.summingInt(x -> x))); + + // Maximum Element in a List + System.out.println(l2.stream().max(Comparator.comparing(x -> x))); // Integer::intValue + + // Last Element in a List + System.out.println(l2.stream().reduce(0, (a, b) -> (b))); + + System.out.println(l2.stream().reduce((a, b) -> (b))); + + // a List of Integers in Descending Order + l1.stream().sorted().toList(); + + // 19. Sort a List of Strings in Alphabetical Order + System.out.println(l2.stream().sorted().toList()); + + // 21. Find the Sum of Digits of a Number + int a = 12345; + + String.valueOf(a).chars() + // .mapToObj(c -> (chars) c) + .map(Character::getNumericValue) /// its should CharSequence + .sum(); + + String.valueOf(a).chars() + .map(Character::getNumericValue) + .sum(); + + // 23. Find the Second-Largest Element in a List + + System.out.println(l2.stream().sorted(Comparator.reverseOrder()).skip(1).findFirst()); + + // 25. Find the Longest String in a List + + l1.stream().max(Comparator.comparing(String::length)); + + // 26. Find the Shortest String in a List + + System.out.println(l1.stream().max(Comparator.reverseOrder())); + + // parttion by even odd + System.out.println(l2.stream().collect(Collectors.partitioningBy(n -> n % 2 == 0))); + + List l4 = List.of(1, 2, 3, 4, 5); + List l5 = List.of(3, 4, 5, 6, 7, 8); + // 32. Find the Union of Two Lists + + l4.stream().filter(l5::contains).toList(); + + // Merge Two Lists into a Single List + Stream.concat(l4.stream(), l5.stream()).toList(); + + // l4.concat() + + ; + // if a List Contains a Specific Element + + } + +} + +@Data +@AllArgsConstructor +class Emp { + String dept, name; + int salary; +} + +class GenEmp { + private T value; + + public void set(T value) { + this.value = value; + } + + public T get() { + return value; + } + +} + +// Sort +// Collections.sort +// \ No newline at end of file diff --git a/src/main/java/com/coreJava/AbstractClass.java b/src/main/java/com/coreJava/AbstractClass.java index ce6426d..a1e02e7 100644 --- a/src/main/java/com/coreJava/AbstractClass.java +++ b/src/main/java/com/coreJava/AbstractClass.java @@ -3,29 +3,59 @@ /* * It can have abstract and non-abstract methods. * It needs to be extended and its method implemented. - * It cannot be instantiated. + * It cannot be instantiated. **** */ - /*Abstract Class can have Implemetation and Non-final fields - * Intereface Can not have Non-final fields i.e Interface cannot carry State - */ +/*Abstract Class can have Implemetation and Non-final fields + * Intereface Can not have Non-final fields i.e Interface cannot carry State + */ +/* Note : though abstract class can have constructor, but we cannot initiate directly + * we need to initialte the base/child class constructor to initilise with super() */ + - abstract class AbstractClass { - String name ; + String name; + + /* Here constructor cannot be initiate directly, it needs base clas constructor with super()*/ AbstractClass(String str) { - this.name= str; + this.name = str; System.out.println("Abstract constructor " + str); } + + public abstract String abstractMethod1(String str); + + public void concreateMethod() { + System.out.println("concreateMethod"); + } } -class TestNew extends AbstractClass{ +class TestNew extends AbstractClass { + + TestNew() { + super("Hello"); + System.out.println("TestNew constructor"); + } + + public String abstractMethod1(String str) { + return "My Name is " + str; + } + + public static void main(String[] args) { + TestNew test = new TestNew(); + + // AbstractClass abstractClass = new AbstractClass("TestNew"); + /*We can not instatiate AbstractClass + * To Call the Concrete method, we need to make Child class object and call parent method */ + test.concreateMethod(); + } - TestNew(String str) { - super(str); - } - public String abstractMethod1(String str) { - return "My Name is "+str; - } -} \ No newline at end of file + +} + +/* +* 1. can't initiate the abstract class ( cannot create object via new ) +* 2.To call Concrete method, we need to make Child class object and call abstract/parent class method +* 3. We can make constructor in abstract class, but cannot call directly, we need to call child class const, and then use super(arg) +* 4. super only called with constructor body only and should have 1st line + * */ diff --git a/src/main/java/com/coreJava/Java21Features.java b/src/main/java/com/coreJava/Java21Features.java new file mode 100644 index 0000000..1908458 --- /dev/null +++ b/src/main/java/com/coreJava/Java21Features.java @@ -0,0 +1,111 @@ +package com.coreJava; + +import lombok.Data; +import org.springframework.web.client.RestClient; + +import java.net.http.HttpClient; +import java.time.Duration; +import java.util.concurrent.Executors; + +record Points(int x, int y) { +} + +record Details(int x, int y) { +} + +@Data +class NewClass { + String name; +} + +// Virtual Threads +// Normal thread in java are managed by OS level. +// Virtual thread are manged by JVM +/* +Virtual threads are lightweight threads managed by the (JVM) rather than by the operating system. + It allow u to create millions of concurrent threads with less memory & resource used compared to traditional platform (OS) threads. +* */ + + +public class Java21Features { + + + public static void main(String[] args) throws InterruptedException { + String name = "Sachin"; + //Preview +// String fullName = StringTemplate.STR." Hello {name} Yadav"; + + + try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { + for (int i = 0; i < 100_000; i++) { + executor.submit(() -> { + // some blocking or I/O operation + }); + } + } + + + staticMethod1(); + Points ps = new Points(10, 20); + staticMethod2(ps); + staticMethod3(ps); + staticMethod4(ps); + restClientMethod(); + } + + + // Latest Switch + private static String staticMethod4(Object obj) { + return switch (obj) { + case Points p -> "Points " + p.x(); + case Details d -> "Details " + d.x(); + case NewClass nc -> "NewClass " + nc.name; + default -> "Default "; + }; + } + + + private static int staticMethod2(Object obj) { + int sum = 0; + if (obj instanceof Points p) { + int a = p.x(); + int b = p.y(); + sum = a + b; + } + return sum; + } + + // Latest Record Pattern + private static int staticMethod3(Object obj) { + if (obj instanceof Points(int x, int y)) { + return x + y; + } + return 0; + } + + + private static void staticMethod1() throws InterruptedException { +// boolean isEmojiChar = Character.isEmoji('????'); + boolean canHaveModifier = Character.isEmojiModifierBase('✋'); + HttpClient client = HttpClient.newHttpClient(); + client.shutdown(); + if (client.awaitTermination(Duration.ofMinutes(1))) { + System.out.println("Client terminated successfully."); + } else { + System.out.println("Client termination took longer than expected."); + } + + } + + + private static void restClientMethod() { + HttpClient client = HttpClient.newHttpClient(); + RestClient rc = RestClient.create(); + NewClass responseBody = rc.get() + .uri("https://www.google.com/") + .retrieve() + .body(NewClass.class); + + } + +} diff --git a/src/main/java/com/coreJava/Java21VirtualThread.java b/src/main/java/com/coreJava/Java21VirtualThread.java new file mode 100644 index 0000000..1b0edee --- /dev/null +++ b/src/main/java/com/coreJava/Java21VirtualThread.java @@ -0,0 +1,53 @@ +package com.coreJava; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +public class Java21VirtualThread { + static int counter = 0; // Note we cannot have counter in main or any method + + public static void main(String[] args) { + normalThradByRunnable(); + normalThradByThreadClass(); + virtualTHreadByRunnable(); + virtualThreadByExecutor(); + } + + private static void normalThradByRunnable() { + Runnable r = () -> { + for (int i = 0; i < 10; i++) { + System.out.println("Hello World " + counter++); + } + };// Thread t1 = new Thread(r); t1.start(); + new Thread(r).start(); + } + + private static void normalThradByThreadClass() { + } + + private static void virtualThreadByExecutor() { + Runnable r = () -> System.out.println("Hello World By VirtualThread"); + Thread.ofVirtual().start(r); // Note here we are not using new and Thread(r) . we are providing r to start() + + } + + private static void virtualTHreadByRunnable() { + Executors.newFixedThreadPool(2).execute(() -> {}); + Executors.newCachedThreadPool().execute(() -> {}); + + + + try (ExecutorService es = Executors.newVirtualThreadPerTaskExecutor();) { + for (int i = 0; i < 10; i++) { + es.submit(() -> { + System.out.println("Hello World " + counter++); + }); + } + } + } + +} + + +/// Executors +// newFixed \ No newline at end of file diff --git a/src/main/java/com/coreJava/SimpleInterface1.java b/src/main/java/com/coreJava/SimpleInterface1.java index 1d339a8..161adc8 100755 --- a/src/main/java/com/coreJava/SimpleInterface1.java +++ b/src/main/java/com/coreJava/SimpleInterface1.java @@ -21,6 +21,8 @@ interface Printable { void print(); } + + public class SimpleInterface1 implements Printable { public void print() { System.out.println(" Inside Printable "); @@ -30,6 +32,22 @@ public static void main(String[] args) { SimpleInterface1 intface = new SimpleInterface1(); intface.print(); + Printable p = (() -> System.out.println("Inside Printable ")); + p.print(); + } -} \ No newline at end of file +} + +/* THIS IS FUNCTIONAL INTERFACE IMPL*/ + +/* Simply call the Interface name to */ + +class Testing { //implements Printable *NOTE HERE we are not implementing * + public void func(String[] args) { + Printable p = () -> { + System.out.println("Print My pet "); + }; + p.print(); + } +} diff --git a/src/main/java/com/coreJava/SimpleInterface2.java b/src/main/java/com/coreJava/SimpleInterface2.java index 25ced69..6938744 100755 --- a/src/main/java/com/coreJava/SimpleInterface2.java +++ b/src/main/java/com/coreJava/SimpleInterface2.java @@ -1,22 +1,36 @@ package com.coreJava; -interface shape { +import java.util.function.BiConsumer; +import java.util.function.BiFunction; +import java.util.function.Predicate; + +@FunctionalInterface +interface Shape { String shapeDetails(); } -class rect implements shape { +class Rect implements Shape { + + // Shape s = () -> { return "Rectangle Shape";}; + Shape s = () -> "Rectangle Shape"; // Both are same + public String shapeDetails() { return "rectangle"; } } -class circle implements shape { +class Circle implements Shape { + Shape s = () -> "Circle Shape"; + public String shapeDetails() { return "circle"; } } -class square { +class Square { + Shape sq = () -> "Square Shape"; + + public String shapeDetails() { return " square "; } @@ -26,10 +40,21 @@ public String shapeDetails() { public class SimpleInterface2 { public static void main(String[] args) { - rect a = new rect(); + Rect a = new Rect(); System.out.println(a.shapeDetails()); - square s = new square(); + Square s = new Square(); System.out.println(s.shapeDetails()); + + Predicate p = (str) -> str.length() > 5; // (a) -> a.length() > 5 ? true : false; + boolean pTest = p.test("Hello123"); + + + BiConsumer biC = (str1, int1) -> System.out.println(str1 + " " + int1); + + + BiFunction biF = (str1, str2) -> (str1 + str2).length(); + + //We can Create our default Functions like that } } diff --git a/src/main/java/com/coreJava/SimpleInterface3.java b/src/main/java/com/coreJava/SimpleInterface3.java new file mode 100644 index 0000000..8019994 --- /dev/null +++ b/src/main/java/com/coreJava/SimpleInterface3.java @@ -0,0 +1,45 @@ +package com.coreJava; + +import java.util.function.BiFunction; +import java.util.function.Function; + +interface aInterface { + void method(); +} + +interface bInterface { + void method(); +} + +interface cInterface { + int method(); +} + + +//We can Create our default Functions like that BiFunction + +@FunctionalInterface +interface TriFunction { + D reply(A a, B b, C c); +} + +public class SimpleInterface3 { + BiFunction biF = (str1, str2) -> (str1 + str2).length(); + + static TriFunction triF = (str1, str2, str3) -> (str1 + str2 + str3).length(); + + public static void main(String[] args) { + int as = triF.reply("MY", "NAME", "SACHIN"); + System.out.println(as); + } + +} +class LoggingFunction implements Function { + public String apply(String s) { + System.out.println("Input: " + s); + return s.toUpperCase(); + } + // OR + // Function fn = (str) -> str.toUpperCase(); + +} \ No newline at end of file diff --git a/src/main/java/com/coreJava/SimpleJava.java b/src/main/java/com/coreJava/SimpleJava.java new file mode 100644 index 0000000..d585187 --- /dev/null +++ b/src/main/java/com/coreJava/SimpleJava.java @@ -0,0 +1,81 @@ +package com.coreJava; + +/* When Static block is there, + * you can declare a static block that gets executed exactly once, when the class is first loaded. */ + + +class NewCounter { + static int counter = 0; // shared across all objects ********** + int counts = 0; // separate for each object ********** + + public void increment() { + counts++; + counter++; + System.out.println("Counter: " + counter); + System.out.println("Counts: " + counts); + } +} + +class SampleClass1 { + public SampleClass1() { + System.out.println("SampleClass1 constructor"); + } + + int a = 11; + static int b = 22; + + + public static void Method1_1() { + System.out.println("Inside SampleClass1 Method1_1"); + System.out.println(b); // As Method1_1 is called ,but constructor is still not called bcoz new keyword is not called yet. + System.out.println(new SampleClass1().a + b); //Here as new is called , so First constructor is called + } + + public void Method1_2() { + System.out.println("Inside SampleClass1 Method1_2"); + System.out.println(new SampleClass1().a + b); //Here as new is called , so First constructor is called + } + + static { + System.out.println("SampleClass1 static block !!!"); + } + +} + + +public class SimpleJava { + int a = 1; + static int b = 2; + + public static void main(String[] args) { + + // System.out.println(a); // new can not access it + System.out.println(new SimpleJava().a); + System.out.println("Sample Class Start !!! " + b); + +// new SampleClass1().Method1_2(); + newStaticMethod_1(); + + } + + static void newStaticMethod_1() { + System.out.println("Inside newStaticMethod_1"); + + NewCounter counter = new NewCounter(); //creates a new object // and its counts is initialized to 0 + + counter.increment(); + NewCounter counter1 = new NewCounter(); // Here whenever new obj create . + counter1.increment(); + } +/* Result : +Counter: 1 +Counts: 1 +Counter: 2 +Counts: 1 + + +✅ counter is static → shared by all instances of NewCounter +✅ counts is non-static → each object has its own version*/ + +} + diff --git a/src/main/java/com/coreJava/TestSampleClass.java b/src/main/java/com/coreJava/TestSampleClass.java new file mode 100644 index 0000000..2d94134 --- /dev/null +++ b/src/main/java/com/coreJava/TestSampleClass.java @@ -0,0 +1,92 @@ +package com.coreJava; + +import java.util.Arrays; + +public class TestSampleClass { + + + private static void insertationSort(){ + int arr[] = {5,6,3,1,9,3} ; // 5 6 3 1 + int len = arr.length; + for (int i = 1; i < len; i++) { + for(int j = i; j >0; j--){ + if(arr[j] < arr[j-1]){ + int tmp = arr[j]; + arr[j] =arr[j-1] ; + arr[j-1]=tmp; + } + } + } + System.out.println("$$$$" +Arrays.toString(arr)); + } + + private static void swap(int []arr ,int i ,int j){ + + } + + public static void main(String[] args) { + insertationSort(); + /* + * 5,6,3,1,9 + * + * + * + * */ + + +//Bubble Sort +// int arr[] = {5,6,3,1,9} ; +// int len = arr.length-1; +// for (int i = 0; i < len; i++) { +// for (int j = 0; j < len; j++) { +// if (arr[j] > arr[j+1]) { +// int temp = arr[j]; +// arr[j] = arr[j+1]; +// arr[j+1] = temp; +// }System.out.println(Arrays.toString(arr)); +// } System.out.println( "***"+Arrays.toString(arr)); +// } +// System.out.println(Arrays.toString(arr)); + + +// int arr1[] ={1,2,3,4,5} ; //5 +// int arr2[] ={4,1,3,5}; //4 +// int a = arr1.length; +// int b = arr2.length; +// int arr3[] = new int[a+b] ; +// for(int i=0;i arr[j]){ +// max = arr[j]; +// p=j; +// } +// } +// arr[p]=arr[i]; +// arr[i]= max; +// } +// System.out.println(Arrays.toString(arr)); + /***************************/ + + + + + + + } +} diff --git a/src/main/java/com/devoxx/LazyInitialization/LambdaExpressions1.java b/src/main/java/com/devoxx/LazyInitialization/LambdaExpressions1.java index 0d8c01a..1b67942 100644 --- a/src/main/java/com/devoxx/LazyInitialization/LambdaExpressions1.java +++ b/src/main/java/com/devoxx/LazyInitialization/LambdaExpressions1.java @@ -11,6 +11,7 @@ public class LambdaExpressions1 { public static void main(String[] args) { int value = 4; + String tmp =""; int temp = compute(value); if (value > 4 && temp > 100) { // Here It is Eager initialization . Here Compute is Called, though it is not needed. System.out.println("Part 1 with " + temp); diff --git a/src/main/java/com/devoxx/LazyInitialization/TestClassNew.java b/src/main/java/com/devoxx/LazyInitialization/TestClassNew.java new file mode 100644 index 0000000..a8945fe --- /dev/null +++ b/src/main/java/com/devoxx/LazyInitialization/TestClassNew.java @@ -0,0 +1,52 @@ +package com.devoxx.LazyInitialization; + + +/*Given an array of integers arr, return true if the number of occurrences of each value in the array is unique or false otherwise. +Example 1: + +Input: arr = [1,2,2,1,1,3]Output: true +Explanation: The value 1 has 3 occurrences, 2 has 2 and 3 has 1. No two values have the same number of occurrences. + */ + +import java.util.*; +import java.util.function.Function; +import java.util.stream.Collectors; + +public class TestClassNew { + + public static void main(String[] args) { + + + + + + + Integer arr[] = {1, 2, 2, 1, 1, 3,4}; + List l = Arrays.asList(arr); + Map map = l.stream() + .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); + Set entrySet = new HashSet<>(map.values()); //3, 2,1 + var value = entrySet.stream().reduce(0L, (a, b) -> a + b); + System.out.println(entrySet); + System.out.println(value); + if(arr.length != value) + { System.out.println("false");} + else{ + System.out.println("true");} + + + + +//if( entrySet) +// +// +// for ( Map.Entry val : entrySet ){ +// val. +// } +// +// System.out.println(map); +// } + } +} + + diff --git a/src/main/java/com/advanceJava/SelectionSort.java b/src/main/java/com/dsa/SortingFactoryMethod/SelectionSort.java similarity index 95% rename from src/main/java/com/advanceJava/SelectionSort.java rename to src/main/java/com/dsa/SortingFactoryMethod/SelectionSort.java index fa5175b..709d700 100755 --- a/src/main/java/com/advanceJava/SelectionSort.java +++ b/src/main/java/com/dsa/SortingFactoryMethod/SelectionSort.java @@ -1,4 +1,4 @@ -package com.advanceJava; +package com.dsa.SortingFactoryMethod; import java.util.Arrays; diff --git a/src/main/java/com/dsa/SortingFactoryMethod/SortFactory.java b/src/main/java/com/dsa/SortingFactoryMethod/SortFactory.java index de36475..2a2408f 100644 --- a/src/main/java/com/dsa/SortingFactoryMethod/SortFactory.java +++ b/src/main/java/com/dsa/SortingFactoryMethod/SortFactory.java @@ -6,7 +6,7 @@ public class SortFactory { public Sorting startSortFactory(String sort){ return switch (sort) { - case "SelectionSort" -> new SelectionSort(); + // case "SelectionSort" -> new SelectionSort(); case "BubbleSort" -> new BubbleSort(); case "MergeSort" -> new MergeSort(); case "InsertionSort" -> new InsertionSort(); diff --git a/src/main/java/com/dsa/SortingFactoryMethod/algorithms/SimpleMatrixMultiply.java b/src/main/java/com/dsa/SortingFactoryMethod/algorithms/SimpleMatrixMultiply.java index a770e31..c4688ff 100644 --- a/src/main/java/com/dsa/SortingFactoryMethod/algorithms/SimpleMatrixMultiply.java +++ b/src/main/java/com/dsa/SortingFactoryMethod/algorithms/SimpleMatrixMultiply.java @@ -7,7 +7,8 @@ public class SimpleMatrixMultiply implements Sorting { @Override public void startSort(int[] a) { startMultiple(); - int[][][] matrix = {{{1}, {2}, {2}, {1}, {2}, {2}, {2}, {1, 5}}, + int[][][] matrix = { + { {1}, {2}, {2}, {1}, {2}, {2}, {2}, {1, 5} }, {{5}, {6}, {2}, {1}, {5, 6, 7, 8, 9}}, {{5, 6, 7, 8, 9}}, {{9, 9, 9, 9, 9}} diff --git a/src/main/java/com/dsa/algo/BubbleSelectionInsertion.java b/src/main/java/com/dsa/algo/BubbleSelectionInsertion.java new file mode 100644 index 0000000..794706c --- /dev/null +++ b/src/main/java/com/dsa/algo/BubbleSelectionInsertion.java @@ -0,0 +1,167 @@ +package com.dsa.algo; + +import com.advanceJava.CollectionUtils; + +import java.util.Arrays; +import java.util.List; + +public class BubbleSelectionInsertion { + + + private static void insertationSort(){ + int arr[] = {5,6,3,1,3,9} ; // 5 6 3 1 + int len = arr.length; + for (int i = 1; i < len; i++) { + for(int j = i; j >0; j--){ + if(arr[j] < arr[j-1]){ + int tmp = arr[j]; + arr[j] =arr[j-1] ; + arr[j-1]=tmp; + } + } + } + System.out.println("$$$$" +Arrays.toString(arr)); + } + + private static void swap(int []arr ,int i ,int j){ + int tmp = arr[i]; + arr[i] =arr[j] ; arr[j]=tmp; + } + + private static void bubbleSort(){ + int arr[] = {5,6,3,1,9} ; + int len = arr.length-1; + for (int i = 0; i < len; i++) { + for (int j = 0; j < len; j++) { + if (arr[j] > arr[j+1]) { + int temp = arr[j]; + arr[j] = arr[j+1]; + arr[j+1] = temp; + }System.out.println(Arrays.toString(arr)); + } System.out.println( "***"+Arrays.toString(arr)); + } + System.out.println(Arrays.toString(arr)); + } + +private static void selectionSort() { + /*Selection Sort ; here it takes the minimum element and replace*/ + int arr[] = {5,6,3,1,9} ; + int len = arr.length; + for (int i=0;i arr[j]){ + max = arr[j]; + p=j; + } + } + arr[p]=arr[i]; + arr[i]= max; + } + System.out.println(Arrays.toString(arr)); +} + +/*Insertation sort +* 4,7,5,2,6 +* 4,5,7,2,6 +* 4,5,7 +* 2,4,5,7,6 +* */ + + + + + + + + + + + + public static void main(String[] args) { + List numbers = List.of(1, 2, 3, 4, 5); + int max = numbers.stream().max(Integer :: compareTo).orElse(0); + System.out.println("Max: " + max); + int a[] = CollectionUtils.getShortIntArray(); + System.out.println("Initial " + Arrays.toString(a)); + // selectionSortMethod(a); + int b[] = {6, 5, 3, 4, 7}; + int c[] = {6, 5, 3, 4, 7}; + insertationSort(b); + bubbleSort(c); + + System.out.println("************"); + // selectionSort(CollectionUtils.getShortIntArray()); + + } + + + + // find shortest and put at front + private static void insertationSort(int[] a) { + for (int i = 0; i < a.length; i++) { + for (int j = i; j < a.length; j++) { + if (a[i] > a[j]) { + int tmp = a[i]; + a[i] = a[j]; + a[j] = tmp; + } + } + // System.out.println(Arrays.toString(a)); + } + System.out.println(Arrays.toString(a)); + } + + private static void bubbleSort(int[] a) { + for (int i = 0; i < a.length; i++) { + for (int j = 0; j < a.length; j++) { + if (a[i] < a[j]) { + int tmp = a[i]; + a[i] = a[j]; + a[j] = tmp; + } + } + } + System.out.println("Bubble Sort"); + System.out.println(Arrays.toString(a)); + } + +// private static void selectionSort(int a[]) { +// for (int i = 0; i <= a.length; i++) { +// for (int j = i - 1; j > 0; j--) { +// if (a[j] < a[j - 1]) { +// var t = a[j]; +// a[j] = a[j - 1]; +// a[j - 1] = t; +// } +// } +// } +// System.out.println(Arrays.toString(a)); +// } +// +// private static void selectionSortMethod(int[] a) { +// for (int i = 0; i < a.length; i++) { +// for (int j = i; j > 0; j--) { +// if (a[i] < a[j - 1]) { +// a[j] = a[j - 1]; +// a[j - 1] = a[i]; +// } +// } +// } +// } + + // 3,4, 2,1 5,4 , + // 3,4, 2,1 5,4 + // 3,2, 4 + // 3,2, 1, 4 + // 3,2, 1, 4 ,5 + // 3,2, 1, 4 ,4,5 + + // 2,3 + // 2,1,3 + // 2,1,3,4,4,5 + // + + +} diff --git a/src/main/java/com/dsa/algo/BubbleSort.java b/src/main/java/com/dsa/algo/BubbleSort.java index 1a4f5df..6146334 100644 --- a/src/main/java/com/dsa/algo/BubbleSort.java +++ b/src/main/java/com/dsa/algo/BubbleSort.java @@ -8,35 +8,16 @@ public class BubbleSort { public static void main(String[] args) { int a[] = CollectionUtils.getIntArray(); - BubbleAlgo( a); - System.out.println(Arrays.toString(a)); - // swapValuesUsingXOROperator(a,b); - } - - static void BubbleAlgo(int[] a) { - var n = a.length; - for (int i = 0; i < n - 1; i++) { - for (int j = 0; j < n - 1 - i; j++) { - if (a[j] < a[j + 1]) { - swap(a[j], a[j + 1]); - } - } - } - } - // Collections.swap(list, 0, 4); - private static void swap(int i, int j) { - var t = i; - i = j; - j = t; + System.out.println(Arrays.toString(a)); + // swapValuesUsingXOROperator(a,b); } static void swapValuesUsingXOROperator(int m, int n) { - m = m ^ n; + m = m ^ n; n = m ^ n; m = m ^ n; - System.out.println("Value : " + m+ " and " + n); - + System.out.println("Value : " + m + " and " + n); } } diff --git a/src/main/java/com/dsa/algo/FibonacciByDynamicProgram.java b/src/main/java/com/dsa/algo/FibonacciByDynamicProgram.java new file mode 100644 index 0000000..c2b2735 --- /dev/null +++ b/src/main/java/com/dsa/algo/FibonacciByDynamicProgram.java @@ -0,0 +1,28 @@ +package com.dsa.algo; + +import java.util.Arrays; + +public class FibonacciByDynamicProgram { + static int p = 0; + static int j = 0; + + public static void main(String[] args) { + int[] arr = {-1, -1, -1, -1, -1, -1, -1, -1}; + var a = fibonacci(7, arr); + System.out.println("" + a); + System.out.println(":::" + Arrays.toString(arr)); + } + + private static int fibonacci(int n, int[] arr) { + System.out.println("Getting for N:" + n + " ^^^ " + j++); + if (arr[n] == -1) { + if (n <= 1) + return n; + var t = fibonacci(n - 2, arr) + fibonacci(n - 1, arr); + arr[n] = t; + return t; + } else + return arr[n]; + } + +} diff --git a/src/main/java/com/dsa/algo/FibonacciByRecursion.java b/src/main/java/com/dsa/algo/FibonacciByRecursion.java new file mode 100644 index 0000000..e35a170 --- /dev/null +++ b/src/main/java/com/dsa/algo/FibonacciByRecursion.java @@ -0,0 +1,48 @@ +package com.dsa.algo; + +public class FibonacciByRecursion { + static int p = 0; + static int j = 0; + + public static void main(String[] args) { + + System.out.println(fibonacci1(7)); + fibonacciByIterativeLoop(6); + // int[] arr = {-1, -1, -1, -1, -1, -1, -1, -1}; + // var a = fibonacci(7, arr); + } + + // n s + // 1 1 2 3 5 8 13 21 34 + private static void fibonacciByIterativeLoop(int no) { + System.out.println("Fibo by Interative"); + int pre = 0;// 1; + int sum = 1;// 2; + for (int i = 0; i < no; i++) { + int tmp = sum; + sum = sum + pre; + pre = tmp; + } + System.out.println(sum); + } + + private static int fibonacci1(int n) { + System.out.println("Getting for N:" + n + " ^ " + p++); + if (n <= 1) + return n; + return fibonacci1(n - 2) + fibonacci1(n - 1); + } + +} + +// private static int fibonacci(int n, int[] arr) { +// System.out.println("Getting for N:" + n + " ^^^ " + j++); +// if (arr[n] == -1) { +// if (n <= 1) +// return n; +// var t = fibonacci(n - 2, arr) + fibonacci(n - 1, arr); +// arr[n] = t; +// return t; +// } else +// return arr[n]; +// } diff --git a/src/main/java/com/dsa/algo/InsertationSort1.java b/src/main/java/com/dsa/algo/InsertationSort1.java deleted file mode 100644 index ff2a44c..0000000 --- a/src/main/java/com/dsa/algo/InsertationSort1.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.dsa.algo; - -public class InsertationSort1 { - - public static void main(String[] args) { - int a[] = { 43, 8, 9, 2, 4,5,3}; - int n = a.length; - - for (int i = 0; i <= n; i++) { - - for (int j = i - 1; j > 0; j--) { - - if (a[j] < a[j - 1]) { - var t = a[j]; - a[j] = a[j - 1]; - a[j - 1] = t; - } - } - - for (int m : a) - System.out.print(m + " "); - System.out.println(""); - } - } -} diff --git a/src/main/java/com/dsa/algo/MergeSort1.java b/src/main/java/com/dsa/algo/MergeSort1.java index 48cbafb..c907e64 100644 --- a/src/main/java/com/dsa/algo/MergeSort1.java +++ b/src/main/java/com/dsa/algo/MergeSort1.java @@ -5,56 +5,45 @@ /* * Merge Sort is Combine/merge 2 Smaller SORTED list into 1 Single SORTED List */ + public class MergeSort1 { - public static void main(String[] args) { - int a[] = { 3, 5, 7,18}; - int b[] = { 1, 4, 19, 21, 24 }; - int c[] = Merge(a, b); - int d[]= newMerge(a,b); - for(int i=0;i()); + try { + ExecutorService executor = Executors.newFixedThreadPool(5); + executor.execute( + new Runnable() { + @Override + public void run() { + + try { + Thread.sleep(4000); + System.out.println("Hello World"); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + }); + + } catch (Exception e) { + System.out.println(e); + } + + + try { + ExecutorService executor = Executors.newFixedThreadPool(5); + executor.submit( + new Runnable() { + @Override + @SneakyThrows // + public void run() { + Thread.sleep(4000); + System.out.println("Hello World Via Submit"); + + } + + }); + + } catch (Exception e) { + System.out.println(e); + } + + + + + + ExecutorService executor = Executors.newFixedThreadPool(5); + + executor.execute(new Multithreading2(1, "Sachin")); + executor.execute(new Multithreading2(2, "Yadav")); + + executor.shutdown(); + + } + + +} diff --git a/src/main/java/com/multiThreading/ExecutorSerivce2.java b/src/main/java/com/multiThreading/ExecutorSerivce2.java new file mode 100644 index 0000000..7255717 --- /dev/null +++ b/src/main/java/com/multiThreading/ExecutorSerivce2.java @@ -0,0 +1,17 @@ +package com.multiThreading; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +public class ExecutorSerivce2 { + public static void main(String[] args) { + ExecutorService exe_service = Executors.newCachedThreadPool(); + exe_service.execute(() -> System.out.println("Hello World!")); + exe_service.execute(() -> newMethod1()); + + exe_service.shutdown(); + } + + private static void newMethod1() { + } +} diff --git a/src/main/java/com/multiThreading/ExecutorServiceWithFuture.java b/src/main/java/com/multiThreading/ExecutorServiceWithFuture.java new file mode 100644 index 0000000..4dd9e93 --- /dev/null +++ b/src/main/java/com/multiThreading/ExecutorServiceWithFuture.java @@ -0,0 +1,102 @@ +package com.multiThreading; + +import java.util.Arrays; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +import static java.util.concurrent.Executors.newSingleThreadExecutor; + +class Test implements Runnable { + int counter = 0; + + public Test() { + } + + public Test(int counter) { + this.counter = counter; + } + + @Override + public void run() { + counter++; + System.out.println("Counter value is " + counter); + } +} + + +class ExecutorServiceImpl { + int count = 0; + int start = 0; + + public void executorServ() { + try (ExecutorService executor = newSingleThreadExecutor()) { + var r = executor.submit(() -> { + }); // Both working are same , It returns Future + executor.execute(() -> { + }); // Both working are same , It returns Nothing + + // executor.execute(method1()); // here it need Runnable OR Callable type not normal method return type + executor.execute(new Test()); // Here It requires runnable , Test had Runnable interface + + /* Another Way to write */ + executor.execute(new Runnable() { + @Override + public void run() { + } + }); + + executor.execute(new Test(13)); + System.out.println("# "); + + /* Another Way to write. This is good for US */ + executor.execute(() -> { + count++; + System.out.println("<>-<>" + Thread.currentThread().getName() + ": " + count); + var t = method1(); + System.out.println("|^^|" + t); + }); + + for (int i = 0; i < 5; i++) { + // executor.execute(new Test()); + } + + /* WORK WITH FUTURE */ + Future future = executor.submit(() -> "Result from task"); + String result = future.get(); + System.out.println("Check the result :" + result); + + Future future1 = executor.submit(() -> { + Thread.sleep(5000); + return "Result from task"; + }); + String result1 = future1.get(3000, TimeUnit.MILLISECONDS); + System.out.println("Check the New result :" + result1); + + /*As Future . get() didn't get the response in specific time period,so it gives TimeoutException */ + + executor.shutdown(); + // executor.shutdownNow(); + + } catch (TimeoutException e) { + System.err.println("It gives the Timeout " + Arrays.toString(e.getStackTrace())); + } catch (Exception e) { + System.err.println(e); + } + } + + public String method1() { + return "String Method Yo Yo Yo "; + } +} + + +public class ExecutorServiceWithFuture { + + public static void main(String[] args) { + ExecutorServiceImpl e = new ExecutorServiceImpl(); + e.executorServ(); + } + +} diff --git a/src/main/java/com/multiThreading/MultiThreading4.java b/src/main/java/com/multiThreading/MultiThreading4.java new file mode 100644 index 0000000..3b4b24d --- /dev/null +++ b/src/main/java/com/multiThreading/MultiThreading4.java @@ -0,0 +1,167 @@ +package com.multiThreading; + +import java.util.concurrent.Callable; + +import org.springframework.web.bind.annotation.ExceptionHandler; + +// All about Threads (not concurrency/executorserivce/threadpool) + +/* Theads*/ +/* LifeCycle + * +NEW : created but not started +RUNNABLE: Thread ready to run or running +BLOCKED : Waiting to acquire lock +WAITING : Waiting indefinitely for another thread (e.g., join()) +TIMED_WAITING : Waiting for a specific time (e.g., sleep(ms)) +TERMINATED :Thread has finished execution +*/ + +/* Ways + * Thread class + * + * Runnable interface +*/ + +// Thread Using Lambda + +// + +class RunnableI implements Runnable { + + @Override + public void run() { + Thread.currentThread().getName(); + } + +} + +class ThreadClass extends Thread { + public void run() { + System.out.println("Hello "); + } + + public void method1() { + System.out.println("Hello Method 1 "); + } +} + +public class MultiThreading4 { + + public static void main(String[] args) { + callByThreadClass(); + callBYRunnableInterface(); + callByLambda(); + threadMethods(); + } + + private static void callByThreadClass() { + ThreadClass thr = new ThreadClass(); + thr.start(); + } + + private static void callBYRunnableInterface() { + RunnableI r = new RunnableI(); + // r.run(); //Can Start by this way also + Thread thread = new Thread(r); + thread.start(); + } + + private static void callByLambda() { + int t = 5; + // Note Here We are calling Runnable method + new Thread(() -> simpleMethod1(5)).start(); + // Extended version + + // We cannot pass variable like below, as it implements run method + + // Runnable r = (int p) -> System.out.println("Thread using lambda" + p); + // Runnable r = (var s) -> System.out.println("Hello " + s); + + Runnable r = () -> System.out.println("Hello "); + new Thread(r).start(); + + Thread t1 = new Thread(() -> { + for (int i = 0; i < 10; i++) { + System.out.println("Yo " + i); + } + }); + + Thread t2 = new Thread(() -> { + System.out.println("T2 waiting for T1..."); + try { + t1.join(); // wait for t1 to finish + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("T2 started after T1"); + }); + + } + + static void simpleMethod1(int n) { + System.out.println("Simple Method 1" + n * n); + + Thread t = new Thread(() -> { + for (int i = 0; i < 10; i++) { + System.out.println("Yo " + i); + } + }); + t.setDaemon(true); + t.setPriority(n); + t.setName("MyThread"); + t.getName(); + // t.join(); // Main thread will wait for t to finish + + } + + // private static Callable simpleMethod(int a) { + // return new Callable() { + // }; } + + @ExceptionHandler(Exception.class) + private static void threadMethods() { + Thread t = new Thread(() -> { + try { + System.out.println("Sleeping for 5 sec"); + Thread.sleep(5000); // Will be interrupted + System.out.println("Woke up normally"); + } catch (InterruptedException e) { + System.out.println("Thread was interrupted!"); + } + }); + + t.start(); + // Thread.sleep(1000); + // Let thread sleep for 1 sec + t.interrupt(); + } + +} + +class MethodDeclare implements Runnable { + public void run() { + + } +} +// isAlive -> check thread is still running +// sleep -> +// join -> wait for other threads to finish +// yield -> pause to let other thread execute +// priority -> setPriority(1 -10) +// run -> code to execute in thread +// getName -> get the name of thread +// interrupt -> interrupt a sleeping/waiting thread +// currentThread() -> returns current existing thread + +// https://www.geeksforgeeks.org/java/synchronization-in-java/ + +/* + * // Constructors + * Thread() // new thread, no task + * Thread(Runnable target) // takes Runnable task + * Thread(String name) // thread with name + * Thread(Runnable target, String name) // task + name + * + * + */ \ No newline at end of file diff --git a/src/main/java/com/multiThreading/Multithreading1.java b/src/main/java/com/multiThreading/Multithreading1.java index 195a3a7..899af18 100644 --- a/src/main/java/com/multiThreading/Multithreading1.java +++ b/src/main/java/com/multiThreading/Multithreading1.java @@ -5,12 +5,22 @@ * context-switching between the threads takes less time than process (Multi-Processing). */ - //Achieved by 2 ways - // extending Thread Class - // Runnable Interface +//Achieved by 2 ways +// extending Thread Class +// Runnable Interface +// Thread and Runnable are of lang package +public class Multithreading1 extends Thread { + @Override + public void run() { + System.out.println("Multithreading1"); + } -public class Multithreading1 { - + public static void main(String[] args) { + Multithreading1 m = new Multithreading1(); + m.start(); + // + new Multithreading1().start(); + } } diff --git a/src/main/java/com/multiThreading/Multithreading2.java b/src/main/java/com/multiThreading/Multithreading2.java new file mode 100644 index 0000000..6467a45 --- /dev/null +++ b/src/main/java/com/multiThreading/Multithreading2.java @@ -0,0 +1,28 @@ +package com.multiThreading; + +public class Multithreading2 implements Runnable { + int counter = 0; + String name; + + public Multithreading2() { + } + + public Multithreading2(int counter, String name) { + this.name = name; + this.counter = counter; + } + + @Override + public void run() { + System.out.println("Multithreading2 thread started for + " + counter + ":" + name); + } + + + public static void main(String[] args) { + Thread thread = new Thread(new Multithreading2(0, "test")); + thread.start(); + + Thread thread1 = new Thread(new Multithreading2(1, "test_1")); + thread1.start(); + } +} diff --git a/src/main/java/com/multiThreading/Multithreading3.java b/src/main/java/com/multiThreading/Multithreading3.java new file mode 100644 index 0000000..f96d98c --- /dev/null +++ b/src/main/java/com/multiThreading/Multithreading3.java @@ -0,0 +1,17 @@ +package com.multiThreading; + +public class Multithreading3 { + public static void main(String[] args) { + method1(); + } + + private static void method1() { + System.out.println("Method 1 started"); + new Thread(() -> method2()).start(); + } + + private static void method2() { + System.out.println("Method 2 started"); + } + +} diff --git a/src/main/java/com/multiThreading/SampleClass.java b/src/main/java/com/multiThreading/SampleClass.java new file mode 100644 index 0000000..690c002 --- /dev/null +++ b/src/main/java/com/multiThreading/SampleClass.java @@ -0,0 +1,80 @@ +package com.multiThreading; + + +import java.util.*; +import java.util.stream.Collectors; + +public class SampleClass { + + public static void getTopTwoDifferences() { + int arr[] = {3, 1, 3, 4, 5, 8, 4, 3, 4, 7, 3, 2, 1}; + int n = arr.length; + int minVal = arr[0]; + List allValidDiffs = new ArrayList<>(); + + for (int i = 1; i < n; i++) { + if (arr[i] > minVal) { // + int diff = arr[i] - minVal; + allValidDiffs.add(diff); + } else { + minVal = Math.min(minVal, arr[i]);// 1 + } + } + System.out.println("-> "+allValidDiffs); + // Sort and pick top 2 + allValidDiffs.sort(Collections.reverseOrder()); + + List top2 = new ArrayList<>(); + for (int i = 0; i < Math.min(2, allValidDiffs.size()); i++) { + top2.add(allValidDiffs.get(i)); + } + + System.out.println("top2: "+ top2); + } + + + public static void main(String[] args) { + getTopTwoDifferences(); + Map map = new HashMap<>(); + map.put("A", 1); + map.put("B", 2); + map.put("C", 1); + map.put("D", 2); + map.put("E", 1); + map.put("F", 4); +// sorted based on values + + List list4 = List.of("a", "b", "cw", "dw", "eeee", "fffff"); + // geet count and values + System.out.println(list4.stream().collect(Collectors.groupingBy(String::length))); + // get values and count + System.out.println(list4.stream().collect(Collectors.toMap(k -> k, k -> k.length()))); + + + Set sets = Collections.singleton(map.values()); + List list = Collections.singletonList(map.values()); + List l2 = new ArrayList(map.values()); + + Collections.sort(list); + Map map1 = new LinkedHashMap<>(); + + Set> entr = map.entrySet(); + for (Map.Entry e1 : entr) { + for (var valz : list) { + + } + } + // getValue() + + + Set> set = map.entrySet(); + + for (var entry : set) { + + } + + + } + + +} diff --git a/src/main/java/com/multiThreading/SampleClass1.java b/src/main/java/com/multiThreading/SampleClass1.java new file mode 100644 index 0000000..d76e4fb --- /dev/null +++ b/src/main/java/com/multiThreading/SampleClass1.java @@ -0,0 +1,50 @@ +package com.multiThreading; + +import java.util.Comparator; +import java.util.List; + +public class SampleClass1 { + public static void main(String[] args) { + + int[][] arr= { {1,2,3}, + {4,5,6}, + {7,8,9} + }; + // 1 4 7 2 5 8 3 6 9 + //7 ,4 1, 8,5 ,2 , 9, 6 ,3 + rotate90(arr); + + } + + private static void rotate90(int mat[][]) { + for (int i = 0; i < mat.length; i++) { + for (int j = i; j < mat[i].length; j++) { + var tmp = mat[i][j]; + mat[i][j] = mat[j][i]; + mat[j][i] = tmp; + } + } + for (int i = 0; i < mat.length; i++) { + for (int j = 0; j < mat[i].length; j++) { + System.out.print(mat[i][j] + " "); + } + } +int n=mat.length ; + for (int i = 0; i < n; i++) { + for (int j = 0; j < mat[i].length; j++) { + var tmp = mat[i][j]; + mat[i][j] = mat[i][mat[i].length - j - 1]; + mat[i][mat[i].length - j - 1] = tmp; + } + } + + System.out.println(" "); + for (int i = 0; i < mat.length; i++) { + for (int j = 0; j < mat[i].length; j++) { + System.out.print(mat[i][j] + " "); + } + } + + } + +} \ No newline at end of file diff --git a/src/main/java/com/multiThreading/SampleClass2.java b/src/main/java/com/multiThreading/SampleClass2.java new file mode 100644 index 0000000..2ad5fff --- /dev/null +++ b/src/main/java/com/multiThreading/SampleClass2.java @@ -0,0 +1,15 @@ +package com.multiThreading; + +import java.util.ArrayList; +import java.util.List; + +public class SampleClass2 { + public static void main(String[] args) { + //Input: 8, 5, 54, 32, 56, 15, 95, 39, 71, 51 + //Output: 71 + List list = List.of(); + + + + } +} diff --git a/src/main/java/com/multiThreading/SampleJavaClass.java b/src/main/java/com/multiThreading/SampleJavaClass.java new file mode 100644 index 0000000..662997e --- /dev/null +++ b/src/main/java/com/multiThreading/SampleJavaClass.java @@ -0,0 +1,28 @@ +package com.multiThreading; + +public class SampleJavaClass { + + public static void main(String[] args) { + int arr[] = {3, 3, 5, 0, 0, 3, 5, 2, 6, 0, 1, 4, 0}; + // int arr2[] = {1,2, 3,4,5}; + // int arr3[] = {1,2,5,9, 3,4,5}; + int max = 0; + int premax = 0; + + for (int i = 0; i < arr.length; i++) { + for (int j = 0; j < arr.length; j++) { + if (arr[j] - arr[i] > premax) { + premax = arr[j] - arr[i]; + } + + } + } + + // System.out.println(""+arr[start]+""+arr[end]); + // System.out.println( arr[start]- arr[end]); + System.out.println(max); + System.out.println(premax); + + } + +} diff --git a/src/main/java/com/springProject/springProject1/AssessmentApplication.java b/src/main/java/com/springProject/springProject1/AssessmentApplication.java new file mode 100644 index 0000000..eb7ca05 --- /dev/null +++ b/src/main/java/com/springProject/springProject1/AssessmentApplication.java @@ -0,0 +1,16 @@ +package com.springProject.springProject1; + + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.data.jpa.repository.config.EnableJpaRepositories; + +@SpringBootApplication +@EnableJpaRepositories +public class AssessmentApplication { + + public static void main(String[] args) { + SpringApplication.run(AssessmentApplication.class, args); + } + +} diff --git a/src/main/java/com/springProject/springProject1/controller/AuthController.java b/src/main/java/com/springProject/springProject1/controller/AuthController.java new file mode 100644 index 0000000..b7d6408 --- /dev/null +++ b/src/main/java/com/springProject/springProject1/controller/AuthController.java @@ -0,0 +1,4 @@ +package com.springProject.springProject1.controller; + +public class AuthController { +} diff --git a/src/main/java/com/springProject/springProject1/controller/MainController.java b/src/main/java/com/springProject/springProject1/controller/MainController.java new file mode 100644 index 0000000..989549b --- /dev/null +++ b/src/main/java/com/springProject/springProject1/controller/MainController.java @@ -0,0 +1,27 @@ +package com.springProject.springProject1.controller; + +import com.springProject.springProject1.model.Users; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.http.converter.json.MappingJacksonValue; +import org.springframework.web.bind.annotation.*; + +@RestController +public class MainController { + + @RequestMapping(path = "/alert/{id}", method = RequestMethod.GET) + public MappingJacksonValue raiseAlertById(@PathVariable(value = "id") String id) { + return new MappingJacksonValue("Accepted"); + } + + + public ResponseEntity getLogin(@RequestBody Users user) { + String response = ""; + return ResponseEntity + .status(HttpStatus.OK) + .header(HttpHeaders.ACCEPT) + .body(new MappingJacksonValue(response)); + } +} +// Why MappingJacksonValue diff --git a/src/main/java/com/springProject/springProject1/dto/AuthRequest.java b/src/main/java/com/springProject/springProject1/dto/AuthRequest.java new file mode 100644 index 0000000..1dde7e6 --- /dev/null +++ b/src/main/java/com/springProject/springProject1/dto/AuthRequest.java @@ -0,0 +1,7 @@ +package com.springProject.springProject1.dto; + +public class AuthRequest { + private String username; + private String password; + // Getters and setters +} diff --git a/src/main/java/com/springProject/springProject1/dto/AuthResponse.java b/src/main/java/com/springProject/springProject1/dto/AuthResponse.java new file mode 100644 index 0000000..6af3bc2 --- /dev/null +++ b/src/main/java/com/springProject/springProject1/dto/AuthResponse.java @@ -0,0 +1,14 @@ +package com.springProject.springProject1.dto; + + +public class AuthResponse { + private String token; + + public AuthResponse(String token) { + this.token = token; + } + + public String getToken() { + return token; + } +} \ No newline at end of file diff --git a/src/main/java/com/springProject/springProject1/model/UserProfile.java b/src/main/java/com/springProject/springProject1/model/UserProfile.java new file mode 100644 index 0000000..0e0685e --- /dev/null +++ b/src/main/java/com/springProject/springProject1/model/UserProfile.java @@ -0,0 +1,17 @@ +package com.springProject.springProject1.model; + +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; + +import java.io.Serializable; + +public class UserProfile implements Serializable { + private static final long serialVersionUID = 1L; + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + private Long id; + private String firstName; + private String lastName; +} diff --git a/src/main/java/com/springProject/springProject1/model/Users.java b/src/main/java/com/springProject/springProject1/model/Users.java new file mode 100644 index 0000000..bfc9ff5 --- /dev/null +++ b/src/main/java/com/springProject/springProject1/model/Users.java @@ -0,0 +1,19 @@ +package com.springProject.springProject1.model; + + +import jakarta.persistence.Entity; +import jakarta.persistence.Id; +import java.io.Serializable; + +@Entity(name = "user") +public class Users implements Serializable { + + private static final long serialVersionUID = 1L; + + @Id + private int id; + private String name; + private String password; + + +} diff --git a/src/main/java/com/springProject/springProject1/service/LoginInterface.java b/src/main/java/com/springProject/springProject1/service/LoginInterface.java new file mode 100644 index 0000000..d7f7023 --- /dev/null +++ b/src/main/java/com/springProject/springProject1/service/LoginInterface.java @@ -0,0 +1,5 @@ +package com.springProject.springProject1.service + ; + +public class LoginInterface { +} diff --git a/src/main/java/com/springProject/springProject1/service/ServiceInterface.java b/src/main/java/com/springProject/springProject1/service/ServiceInterface.java new file mode 100644 index 0000000..fa0efcb --- /dev/null +++ b/src/main/java/com/springProject/springProject1/service/ServiceInterface.java @@ -0,0 +1,4 @@ +package com.springProject.springProject1.service; + +public interface ServiceInterface { +} diff --git a/src/main/java/com/springProject/springProject1/service/impl/LoginServiceImpl.java b/src/main/java/com/springProject/springProject1/service/impl/LoginServiceImpl.java new file mode 100644 index 0000000..65de675 --- /dev/null +++ b/src/main/java/com/springProject/springProject1/service/impl/LoginServiceImpl.java @@ -0,0 +1,18 @@ +//package com.springProject.service.impl; +// +// +//import org.springframework.security.core.userdetails.UserDetails; +//import org.springframework.security.core.userdetails.UserDetailsService; +// +//public class LoginServiceImpl implements UserDetailsService { +// @Override +// public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { +// // Replace this with DB or user service +// if ("user".equals(username)) { +// return new User("user", new BCryptPasswordEncoder().encode("password"), new ArrayList<>()); +// } else { +// throw new UsernameNotFoundException("User not found"); +// } +// } +//} +//} diff --git a/src/main/java/com/testProject/Main.java b/src/main/java/com/testProject/Main.java new file mode 100644 index 0000000..668ea36 --- /dev/null +++ b/src/main/java/com/testProject/Main.java @@ -0,0 +1,206 @@ +package com.testProject; + +import java.util.*; +import java.util.stream.*; + +public class Main { + public static void main(String... arg) { + System.out.println(); + // System.out.println( sortString("string"));//anagram(); // anagram1(); + // fibonacci(4);// System.out.println("Hello"); //palindrome(); + // bubbleSort(); // insertSort(); + startService(); + } + + static void startService() { + int arr[] = { 3, 5, 2, 3, 4, 8, 1 }; // + int mid = arr.length / 2; + merge(arr, 0, arr.length); + System.out.println("" + Arrays.toString(arr)); + + } + + static void merge(int[] arr, int start, int end) { + if (start < end) { + int mid = (end + start) / 2; + merge(arr, start, mid); + merge(arr, mid + 1, end); + merging(arr, start, mid, end); + } + } + + static void merging(int[] arr, int start, int mid, int end) { + int a = mid - start; + int b = end - mid; + + int n = mid - start; + int[] tmp1 = new int[n]; + + int m = end - mid; + int[] tmp2 = new int[m]; + + for (int i = 0; i < n; i++) { + tmp1[i] = arr[start + i]; + } + for (int i = 0; i < m; i++) { + tmp2[i] = arr[start + i]; + } + + // System.out.println("-" + Arrays.toString(c)); + // System.out.println("--" + Arrays.toString(d)); + + // int i = 0, j = 0, k = 0; + + // while (i < a && j < b) { + // if (c[i] < d[j]) { + // arr[k++] = c[i++]; + // } else { + // arr[k++] = d[j++]; + // } + // } + + // while (i < a) { + // arr[k++] = c[i++]; + // } + + // while (j < b) { + // arr[k++] = d[j++]; + // } + + } + + static void selectSort() { + int arr[] = { 3, 5, 2, 3, 4, 8, 1 }; // + int len = arr.length; + for (int i = 0; i < len; i++) { + for (int j = i; j < len; j++) { + if (arr[j] < arr[j - 1]) + swap(arr, j, j - 1); + } + System.out.println(i + "->" + Arrays.toString(arr)); + } + } + + // i->0 j&j-1 swap + static void insertSort() { + int arr[] = { 3, 5, 2, 3, 4, 8, 1 }; // + int len = arr.length; + for (int i = 0; i < len; i++) { + for (int j = i; j > 0; j--) { + if (arr[j] < arr[j - 1]) + swap(arr, j, j - 1); + } + System.out.println(i + "->" + Arrays.toString(arr)); + } + } + + // check till len-1 j&j+1 -> swap + static void bubbleSort() { + int arr[] = { 5, 4, 8, 2, 1, 9, 3, 1, 7, 10 }; + int len = arr.length; + for (int i = 0; i < len - 1; i++) { + for (int j = 0; j < len - 1; j++) { + if (arr[j] > arr[j + 1]) + swap(arr, j, j + 1); + } + } + System.out.println(Arrays.toString(arr)); + } + + // len -> i&j -> swap + static void bubbleSort1() { + int arr[] = { 9, 5, 4, 8 }; + int len = arr.length; + for (int i = 0; i < len; i++) { + for (int j = 0; j < len; j++) { + if (arr[i] < arr[j]) + swap(arr, i, j); + } + System.out.println(i + "->" + Arrays.toString(arr)); + } + System.out.println(Arrays.toString(arr)); + } + + static void swap(int[] arr, int i, int j) { + int tmp = arr[i]; + arr[i] = arr[j]; + arr[j] = tmp; + } + + static void anagram() { + List list = List.of("abab", "aabb", "bbaa", "baba", "aab", "ccd", "cdc"); + var ll = list.stream() + .collect(Collectors.groupingBy(x -> sortString(x))); + // .sort(Comparator.comparing( String:: valueOf)).toList(); + System.out.println(ll); + } + + static void anagram1() { + List list = List.of("abab", "aabb", "bbaa", "baba", "aab", "ccd", "cdc"); + Map> map = new HashMap<>(); + + for (String val : list) { + String sorted = sortString(val); + if (!map.containsKey(sorted)) + map.put(sorted, new LinkedList()); + + var r = map.get(sorted); + r.add(val); + map.put(sorted, r); + + } + System.out.println(map); + + } + + private static String sortString(String input) { + char[] c = input.toCharArray(); + Arrays.sort(c); + return new String(c); + } + + static void palindrome() { + String word = "patatapq"; + char[] arr = word.toCharArray(); + int lngth = arr.length; + var list = word.chars() + .mapToObj(c1 -> (char) c1) + .collect(Collectors.toList()); + System.out.println(list); + + boolean match = true; + for (int i = 0; i < lngth / 2; i++) { + if (arr[i] != arr[lngth - i - 1]) { + match = false; + break; + } + } + + if (!match) { + System.out.println("Not Palindrome"); + } else { + System.out.println(" Palindrome"); + } + + } + + // Anagram listen stenli + + // + + static void fibonacci(int i) { + // 4 * 3 * 2 + System.out.println(IntStream.range(1, i + 1) + .reduce(1, (a, b) -> a * b)); + } + + static void testMethod() { + int arr[] = { 1, 4, 6, 8, 0, 7 }; + System.out.println(arr.length); + // String to array char / + "MY Word".toCharArray(); + System.out.println(arr); + + } + +} diff --git a/src/main/java/com/testProject/SampleClass.java b/src/main/java/com/testProject/SampleClass.java new file mode 100644 index 0000000..931d5eb --- /dev/null +++ b/src/main/java/com/testProject/SampleClass.java @@ -0,0 +1,61 @@ +package com.testProject; + +import java.io.IOException; + +public class SampleClass { + public static void main(String[] args) throws IOException { +// try can work with finally +// try { +// System.out.println("Hello World!"); +// } finally { +// System.out.println("Goodbye World!"); +// } + +// try with resource not required catch / finally +// try(FileReader fr = new FileReader("text.txt")){ +// System.out.println("Hello World!"); +// } + System.out.println(testFunc()); + // This is cool + /* Response + Initials Hello World! + Finally Goodbye World! + Try Hello World! + */ + // Finally Block always execute and + // if return in finally block , that will return + // else if nothing return in finally , then try/ catch return will execute + + // But this thing not happen always + + + System.out.println(testUpdateFunc()); + // when finally return is commented it returns 1 / + // when finally return is there, it returns 2 + } + + private static int testUpdateFunc() { + int result = 0; + try { + result = 1; + return result; + } finally { + result = 2; + // return result; + } + } + + private static String testFunc() { + try { + System.out.println("Initials Hello World!"); + return "Try Hello World!"; + } catch (Exception e) { + e.printStackTrace(); + return "Catch Hello World!"; + } finally { + System.out.println("Finally Goodbye"); + // return "Finally Goodbye World!"; + } + } + +} diff --git a/src/main/java/com/testProject/TestClass.java b/src/main/java/com/testProject/TestClass.java index 4c82d02..c8dbdbb 100644 --- a/src/main/java/com/testProject/TestClass.java +++ b/src/main/java/com/testProject/TestClass.java @@ -4,21 +4,69 @@ import java.time.format.DateTimeFormatter; import java.time.temporal.IsoFields; import java.util.HashMap; +import java.util.Map; +import java.util.*; public class TestClass { - public static void main(String[] args) { - LocalDate localDate = LocalDate.parse("2024-11-04 18:51:30", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); + + + + void samplemethod() { + LocalDate localDate = LocalDate.parse("2024-11-04 18:51:30", + DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); LocalDate firstDay = localDate.with(IsoFields.DAY_OF_QUARTER, 1L); - System.out.println("******* ..... "+ firstDay); + System.out.println("******* ..... " + firstDay); HashMap map = new HashMap(); map.put("MDR", true); - if ( !map.containsKey("MDR") || !map.get("MDR") ) { + if (!map.containsKey("MDR") || !map.get("MDR")) { System.out.println("MDR not Avail"); } else { System.out.println("MDR Avail"); } } + + public static void main(String[] args) { + var t = "1234"; + String arr[] = { "javaasd", "javaqwe", "jav", "javava" }; + char[] c = t.toCharArray(); + System.out.println(c[2]); + System.out.println(t.charAt(3)); + Arrays.asList(arr); + array_1(); + } + + // Given an array and a target sum, return the indices of the two numbers that + // add up to it. + static void array_1() { + int target = 9; + int ar[] = { 6, 3, 4, 2, 7, 6, 8 }; + Map map = new HashMap<>(); + + for (int i = 0; i < ar.length; i++) { + int comp = target - ar[i]; + if (map.containsKey(comp)) { + System.out.println(map.get(comp) + " " + i); + } + + } + + int length = ar.length; + int i = 0; + + for (int j = 0; j < ar.length; j++) { + for (int j2 = 0; j2 < ar.length; j2++) { + + } + + } + + while (i < length) { + + } + + } + } diff --git a/src/main/java/com/testProject/TestClassSample.java b/src/main/java/com/testProject/TestClassSample.java new file mode 100644 index 0000000..6fd2e76 --- /dev/null +++ b/src/main/java/com/testProject/TestClassSample.java @@ -0,0 +1,71 @@ +package com.testProject; + +import java.util.stream.Collectors; +import java.util.*; +import java.util.stream.*; + +public class TestClassSample { + + static void getLongestSubString() { + String str = "appplepynlpp"; // + var list = Arrays.asList(str.toCharArray()); + str.chars().mapToObj(cq -> (char) cq).collect(Collectors.toList()); + StringBuilder stringBuilder = new StringBuilder(); + StringBuilder newStringBuilder = new StringBuilder(); + HashSet set = new HashSet<>(); + for (int i = 0; i < str.length(); i++) { + char ch = str.charAt(i); + if (set.contains(ch)) { // p l e p + if (newStringBuilder.toString().length() > stringBuilder.toString().length()) { + stringBuilder = newStringBuilder; + } + newStringBuilder = new StringBuilder(); + set.clear(); + // newStringBuilder.append(ch); + // set.add(ch); + } + { + set.add(ch); + newStringBuilder.append(ch); // ap + } + } + var val = newStringBuilder.toString().length() > stringBuilder.toString().length() ? newStringBuilder.toString() + : stringBuilder.toString(); + System.out.println(val); + } + + static void getLongestSubString1() { + String str = "appplepynlpp"; // + List l1 = new ArrayList<>(); + HashMap> map = new HashMap<>(); + char a[] = {}; + int b = a.length; + str.length(); + map.size(); + l1.size(); + + for (int i = 0; i < str.length(); i++) { + char ch = str.charAt(i); + if (map.containsKey(ch)) { + + } + + } + } + + public static void main(String[] args) { + getLongestSubString(); // startMerge(); + } + + private static void startMerge() { + int[] arr = { 6, 1, 9, 5, 2, 3, 7, 4 }; + mergeSort(arr, 0, arr.length); + } + + private static void mergeSort(int[] arr, int start, int end) { + if (start < end) { + + } + } + +}