Merge branch 'dev' into 'master'

Dev

See merge request !2

.gitignore

+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store
\ No newline at end of file

.idea/encodings.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding">
+    <file url="file://$PROJECT_DIR$/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/src/main/resources" charset="UTF-8" />
+  </component>
+</project>
\ No newline at end of file

.idea/misc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="MavenProjectsManager">
+    <option name="originalFiles">
+      <list>
+        <option value="$PROJECT_DIR$/pom.xml" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
\ No newline at end of file

.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

.idea/workspace.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="9f8101a7-5b2c-4954-87b0-248ab1cbb4ea" name="Changes" comment="">
+      <change afterPath="$PROJECT_DIR$/.gitignore" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/.idea/misc.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/.idea/vcs.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/pom.xml" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/main/java/org/example/Main.java" afterDir="false" />
+    </list>
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="MavenImportPreferences">
+    <option name="importingSettings">
+      <MavenImportingSettings>
+        <option name="workspaceImportEnabled" value="true" />
+      </MavenImportingSettings>
+    </option>
+  </component>
+  <component name="ProjectId" id="2LlMJUfx4i2MA45VdRRt6j34Hsa" />
+  <component name="ProjectLevelVcsManager" settingsEditedManually="true" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "RunOnceActivity.OpenProjectViewOnStart": "true",
+    "RunOnceActivity.ShowReadmeOnStart": "true"
+  }
+}]]></component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="9f8101a7-5b2c-4954-87b0-248ab1cbb4ea" name="Changes" comment="" />
+      <created>1676441143910</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1676441143910</updated>
+    </task>
+    <servers />
+  </component>
+</project>
\ No newline at end of file

.mvn/wrapper/maven-wrapper.properties

+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.6/apache-maven-3.8.6-bin.zip
+wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.0/maven-wrapper-3.1.0.jar

README.md

-# java8
-

pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.example</groupId>
+    <artifactId>Java8Test</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.24</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-commons</artifactId>
+            <version>2.7.6</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+</project>
\ No newline at end of file

src/main/java/org/example/ConsumerExamples.java

+package org.example;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+public class ConsumerExamples {
+
+  public static void main(String[] args) {
+    simpleConsumer();
+    biConsumer();
+    inbuiltBiConsumer();
+  }
+
+  private static void inbuiltBiConsumer() {
+    Map<String,String> map=new HashMap<>();
+    map.put("1","1");
+    map.put("2","2");
+    map.forEach((x,y)->System.out.println("inbuiltBiConsumer"+x.concat(y)));
+  }
+
+  private static void biConsumer() {
+    BiConsumer<String, String> biConsumer = (x, y) -> x.concat(y);
+    System.out.println(biConsumer);
+
+  }
+
+  private static void simpleConsumer() {
+    Consumer<String> consumer = x -> System.out.println(x);
+    consumer.accept("Hello ");
+  }
+
+}

src/main/java/org/example/Department.java

+package org.example;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class Department {
+
+  private int    id;
+  private String name;
+
+
+}

src/main/java/org/example/Domain.java

+package org.example;
+
+import lombok.*;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Getter
+@Setter
+public class Domain {
+String name;
+Integer score;
+}

src/main/java/org/example/Employee.java

+package org.example;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+import org.springframework.data.annotation.Id;
+
+import java.util.function.Function;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@ToString
+public class Employee {
+
+    @Id
+    private String id;
+    private String firstName;
+    private String lastName;
+    private double salary;
+    private String department;
+}

src/main/java/org/example/FunctionExamples.java

+package org.example;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+public class FunctionExamples {
+
+  public static void main(String[] args) {
+    simpleFunction();
+    chainFunction();
+    biFunction();
+    biFunctionWithFunction();
+  }
+
+  private static void biFunctionWithFunction() {
+    BiFunction<Integer, Integer, Integer> biFunction = (x, y) -> x + y;
+    Function<Integer, String> function = x -> "Hello".concat(String.valueOf(x));
+    System.out.println("  biFunctionWithFunction :" + biFunction.andThen(function).apply(2, 3));
+  }
+
+  private static void biFunction() {
+    BiFunction<Integer, Integer, List<Integer>> biFunction = (x, y) -> Arrays.asList(x + y);
+    System.out.println(biFunction.apply(2, 3));
+  }
+
+  private static void chainFunction() {
+    Function<String, Integer> function1 = String::length;
+    Function<Integer, Integer> function2 = x -> x * 3;
+    System.out.println(function1.andThen(function2).apply("Hello Test"));
+
+
+  }
+
+  private static void simpleFunction() {
+    Function<String, Integer> function = String::length;
+    System.out.println(function.apply("Test"));
+  }
+
+}

src/main/java/org/example/GroupByExamples.java

+package org.example;
+
+import javafx.util.Pair;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static java.util.stream.Collectors.*;
+
+public class GroupByExamples {
+
+  public static void main(String[] args) {
+
+    List<Person> list = Arrays.asList(new Person(1, "Alex", 100d, new Department(1, "HR")),
+            new Person(2, "Brian", 200d, new Department(1, "HR")),
+            new Person(3, "Charles", 900d, new Department(2, "Finance")),
+            new Person(4, "David", 200d, new Department(2, "Finance")),
+            new Person(5, "Edward", 200d, new Department(2, "Finance")),
+            new Person(6, "Frank", 800d, new Department(3, "ADMIN")),
+            new Person(7, "George", 900d, new Department(3, "ADMIN")));
+
+    System.out.println("GroupByExamples by Simple Condition :" + simpleCondition(list));
+
+    System.out.println(" collect only the person ids in all departments" + personIds(list));
+
+    System.out.println("GroupByExamples by Complex Condition" + complex(list));
+
+    System.out.println("GroupByExamples with Counting" + count(list));
+
+    System.out.println(" GroupByExamples with Average" + average(list));
+
+    System.out.println("   GroupByExamples with Max/Min" + max(list));
+
+    System.out.println("GroupByExamples with Filtering" + filter(list));
+
+
+    Map<Integer, Department> departmentMap = list
+        .stream()
+        .collect(Collectors.toMap(Person::getId, Person::getDepartment));
+  }
+
+  private static Map<Department, List<Person>> filter(final List<Person> list) {
+    return list
+        .stream()
+        .filter(person -> person.getSalary() > 100)
+        .collect(Collectors.groupingBy(Person::getDepartment));
+  }
+
+  private static Map<Department, Optional<Person>> max(final List<Person> list) {
+    return list
+        .stream()
+        .collect(Collectors.groupingBy(Person::getDepartment, maxBy(Comparator.comparing(Person::getSalary))));
+  }
+
+  private static Map<Department, Double> average(final List<Person> list) {
+    return list.stream().collect(Collectors.groupingBy(Person::getDepartment, averagingDouble(Person::getSalary)));
+  }
+
+  private static Map<Department, Long> count(final List<Person> list) {
+    return list.stream().collect(Collectors.groupingBy(Person::getDepartment, counting()));
+  }
+
+  private static Map<Object, List<Integer>> complex(final List<Person> list) {
+    return list
+        .stream()
+        .collect(Collectors.groupingBy(person -> new Pair<>(person.getSalary(), person.getSalary()),
+            Collectors.mapping(Person::getId, toList())));
+
+  }
+
+  private static Map<Department, List<Integer>> personIds(final List<Person> list) {
+    return list.stream().collect(Collectors.groupingBy(Person::getDepartment, mapping(Person::getId, toList())));
+  }
+
+  private static Map<Department, List<Person>> simpleCondition(final List<Person> list) {
+    return list.stream().collect(Collectors.groupingBy(Person::getDepartment));
+  }
+
+
+}

src/main/java/org/example/Java8.java

+package org.example;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.OptionalDouble;
+
+public class Java8 {
+
+    public static void main(String[] args) {
+        Multiplication Total = (a, b) -> a * b;
+        // simple operation of multiplication of 'a' and 'b'
+        System.out.println("Result: " + Total.multiply(30, 60));
+
+        Integer[] arr = new Integer[] { 100, 100, 9, 8, 200 };
+        List<Integer> list = Arrays.asList(arr);
+        // Stored the array as list
+        OptionalDouble avg = list.stream().mapToInt(n -> n * n).filter(n -> n>100).average();
+
+        /* Converted it into Stream and filtered out the numbers
+            which are greater than 100. Finally calculated the average
+        */
+
+        if (avg.isPresent())
+            System.out.println(avg.getAsDouble());
+    }
+}

src/main/java/org/example/Main.java

+package org.example;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Main {
+    public static void main(String[] args) {
+        List<Employee> employeeList = createEmployeeList();
+        List<Employee> employees = employeeList.stream()
+                .filter(e->e.getSalary()>5000)
+                .sorted(Comparator.comparing(Employee::getSalary).reversed())
+                .collect(Collectors.toList());
+        employees.forEach(System.out::println);
+//        Map<String,List<String>> tmp = employeeList.stream()
+//                .collect(Collectors.groupingBy(
+//                        Employee::getDepartment,
+//                        Collectors.mapping(Employee::getFirstName,Collectors.toList())));
+//        employeeList.forEach(System.out::println);
+//        System.out.println(employeeList.get(0)!=null? employeeList.get(0).getFirstName()+" "+employeeList.get(0).getLastName(): "List is empty");
+//        System.out.println(employeeList.stream().collect(Collectors.groupingBy(Employee::getDepartment,Collectors.counting())));
+
+
+
+
+        HashMap<String, Integer> budget = new HashMap<>();
+        budget.put("clothes", 120);
+        budget.put("grocery", 150);
+        budget.put("transportation", 100);
+        budget.put("utility", 130);
+        budget.put("rent", 1150);
+        budget.put("miscellneous", 90);
+
+
+        HashMap<String, Integer> sortBudget = budget.entrySet().stream().sorted(Map.Entry.comparingByValue()).
+                collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue,(e1,e2)->e2,HashMap::new));
+        System.out.println(sortBudget);
+
+
+    }
+
+    private static List<Employee> createEmployeeList() {
+        List<Employee> employeeList = new ArrayList<>();
+        employeeList.add(new Employee("1","kenil","mavani",20000,"Backend"));
+        employeeList.add(new Employee("2","kevin","lakhani",11000,"Backend"));
+        employeeList.add(new Employee("3","sahil","parekh",30000,"Backend"));
+        employeeList.add(new Employee("4","pooja","rathod",5000,"Frontend"));
+        employeeList.add(new Employee("5","james","grill",200000,"Frontend"));
+        return employeeList;
+    }
+}
\ No newline at end of file

src/main/java/org/example/Multiplication.java

+package org.example;
+
+@FunctionalInterface
+public interface Multiplication {
+     // annotation for functional interface
+     int multiply(int a, int b);
+    }

src/main/java/org/example/Person.java

+package org.example;
+
+import lombok.*;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Getter
+@Setter
+public class Person {
+
+  public int        id;
+  public String     name;
+  public Double     salary;
+  public Department department;
+
+}
\ No newline at end of file

src/main/java/org/example/PredicateExamples.java

+package org.example;
+
+import domain.Domain;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BiPredicate;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class PredicateExamples {
+
+  public static void main(String[] args) {
+    predicate();
+    predicateAnd();
+    predicateOr();
+    predicateNegate();
+    predicateChaining();
+    biPredicate();
+    biPredicateAsFunctionArgument();
+  }
+
+  private static void biPredicateAsFunctionArgument() {
+    List<Domain> domainList = Arrays.asList(new Domain("google.com", 1), new Domain("i-am-spammer.com", 10),
+        new Domain("mkyong.com", 0), new Domain("microsoft.com", 2));
+    BiPredicate<String, Integer> biPredicate = (x, y) -> {
+      return (x.equals("google.com") || y == 0);
+    };
+    System.out.println(domainList
+        .stream()
+        .filter(domain -> biPredicate.test(domain.getName(), domain.getScore()))
+        .collect(Collectors.toList()));
+  }
+
+  private static void biPredicate() {
+    BiPredicate<String, Integer> biPredicate = (x, y) -> x.length() == y;
+    System.out.println(biPredicate.test("Bat", 3));
+  }
+
+  private static void predicateChaining() {
+    Predicate<String> startsWithA = x -> x.startsWith("A");
+    Predicate<String> startsWithB = x -> x.startsWith("B");
+    System.out.println(startsWithA.or(startsWithB).test("Bat"));
+  }
+
+  private static void predicateNegate() {
+    List<String> list = Arrays.asList("A", "AA", "AAA", "B", "BB", "BBB");
+    Predicate<String> startsWith = x -> x.startsWith("A");
+    System.out.println(list.stream().filter(startsWith.negate()).collect(Collectors.toList()));
+  }
+
+  private static void predicateOr() {
+    List<String> list = Arrays.asList("A", "AA", "AAA", "B", "BB", "BBB");
+    Predicate<String> startsWith = x -> x.startsWith("A");
+    Predicate<String> length = x -> x.length() > 2;
+    System.out.println(list.stream().filter(startsWith.or(length)).collect(Collectors.toList()));
+  }
+
+  private static void predicate() {
+    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
+    Predicate<Integer> noGreaterThan = x -> x > 5;
+    System.out.println(">>" + list.stream().filter(noGreaterThan).sorted().collect(Collectors.toList()));
+  }
+
+  private static void predicateAnd() {
+    List<Integer> list = Arrays.asList(4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19);
+    Predicate<Integer> greaterThan = x -> x > 10;
+    Predicate<Integer> lessThan = x -> x < 18;
+    System.out.println(list.stream().filter(greaterThan.and(lessThan)).collect(Collectors.toList()));
+  }
+
+
+}

src/main/java/org/example/Testing.java

+package org.example;
+
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Testing {
+
+    // Driver code
+    public static void main(String[] args)
+    {
+        Scanner s = new Scanner(System.in);
+        char[] str = s.nextLine().toCharArray();
+        int n = str.length;
+        HashMap<Character, Integer> map = new HashMap<>();
+        for(char ch:str) {
+            if(map.containsKey(ch)) {
+                map.put(ch,map.get(ch)+1);
+            } else {
+                map.put(ch,1);
+            }
+        }
+
+    }
+}

src/main/java/org/example/multiThreads/Numbers.java

+package org.example.multiThreads;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class Numbers implements Runnable {
+
+    int value;
+    private Print printObject;
+    @Override
+    public void run() {
+        while(value<=10) {
+            this.printObject.print(this.value);
+            this.value+=2;
+        }
+        this.printObject.callForNotifyAll();
+    }
+}

src/main/java/org/example/multiThreads/Print.java

+package org.example.multiThreads;
+
+public class Print {
+    synchronized void  print(int value) {
+        notify();
+        System.out.println(value);
+        try {
+            wait();
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    synchronized void callForNotifyAll() {
+        notifyAll();
+    }
+}

src/main/java/org/example/multiThreads/PrintNumbers.java

+package org.example.multiThreads;
+
+public class PrintNumbers {
+    public static void main(String[] args) {
+        try{
+            Print p =new Print();
+        Thread evenThread = new Thread(new Numbers(0,p),"EvenThread");
+        Thread oddThread = new Thread(new Numbers(1,p),"OddThread");
+        evenThread.start();
+        oddThread.start();
+            evenThread.join();
+            oddThread.join();
+            System.out.println(evenThread.isAlive());
+            System.out.println(oddThread.isAlive());
+        }catch (Exception e) {
+            System.out.println("Ended");
+        }
+    }
+}

src/main/java/org/example/pyramid.java

+package org.example;
+
+import java.util.Scanner;
+
+public class pyramid {
+    public static void main(String[] args) {
+        String data = "aabbcc";
+        String result = "";
+        for(int i=0;i<data.length();i++) {
+            if(result.indexOf(data.charAt(i)) > -1) {
+
+            }
+        }
+    }
+}