Transformed projects into maven project

- added maven configuration
- removed lombok lar library

Author: Taras

binary-search-tree/pom.xml

@@ -0,0 +1,16 @@
+<?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>
+
+    <parent>
+        <artifactId>java-8-parent</artifactId>
+        <groupId>com.bobocode</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>binary-search-tree</artifactId>
+
+
+</project>

binary-search-tree/src/main/java/bobocode/BST.java

@@ -0,0 +1,15 @@
+package bobocode;
+
+import java.util.function.Consumer;
+
+public interface BST<T extends Comparable> {
+    boolean insert(T element);
+
+    int height();
+
+    void inOrderTraversal(Consumer<T> consumer);
+
+    void preOrderTraversal(Consumer<T> consumer);
+
+    void postOrderTraversal(Consumer<T> consumer);
+}

binary-search-tree/src/main/java/bobocode/BinarySearchTree.java

@@ -0,0 +1,93 @@
+package bobocode;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+public class BinarySearchTree<T extends Comparable> implements BST<T> {
+     Node<T> root;
+
+    @Override
+    public boolean insert(T element) {
+        Predicate<Node<T>> predicate = Objects::nonNull;
+        if (predicate.test(root)) {
+            root = new Node<>(element);
+            return true;
+        } else {
+            return insert(root, element);
+        }
+    }
+
+    @Override
+    public int height() {
+        return height(root) - 1;
+    }
+
+    private int height(Node<T> node) {
+        if (node != null) {
+            return 1 + Math.max(height(node.getLeft()), height(node.getRight()));
+        } else {
+            return 0;
+        }
+    }
+
+    private boolean insert(Node<T> node, T element) {
+        if (node.getElement().compareTo(element) > 0) {
+            if (node.getLeft() != null) {
+                return insert(node.getLeft(), element);
+            } else {
+                node.setLeft(new Node<>(element));
+                return true;
+            }
+        } else if (node.getElement().compareTo(element) < 0) {
+            if (node.getRight() != null) {
+                return insert(node.getRight(), element);
+            } else {
+                node.setRight(new Node<>(element));
+                return true;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public void inOrderTraversal(Consumer<T> consumer) {
+        inOrderTraversal(consumer, root);
+    }
+
+    private void inOrderTraversal(Consumer<T> consumer, Node<T> node) {
+        if (node != null) {
+            inOrderTraversal(consumer, node.getLeft());
+            consumer.accept(node.getElement());
+            inOrderTraversal(consumer, node.getRight());
+        }
+    }
+
+    @Override
+    public void preOrderTraversal(Consumer<T> consumer) {
+        preOrderTraversal(consumer, root);
+    }
+
+    private void preOrderTraversal(Consumer<T> consumer, Node<T> node) {
+        if (node != null) {
+            consumer.accept(node.getElement());
+            preOrderTraversal(consumer, node.getLeft());
+            preOrderTraversal(consumer, node.getRight());
+        }
+    }
+
+    @Override
+    public void postOrderTraversal(Consumer<T> consumer) {
+        postOrderTraversal(consumer, root);
+    }
+
+    private void postOrderTraversal(Consumer<T> consumer, Node<T> node) {
+        if (node != null) {
+            postOrderTraversal(consumer, node.getLeft());
+            postOrderTraversal(consumer, node.getRight());
+            consumer.accept(node.getElement());
+        }
+    }
+
+}

binary-search-tree/src/main/java/bobocode/Main.java

@@ -0,0 +1,33 @@
+package bobocode;
+
+import java.util.function.Consumer;
+
+public class Main {
+
+    public static void main(String[] args) {
+        BinarySearchTree<Integer> intTree = new BinarySearchTree<>();
+        intTree.insert(9);
+        intTree.insert(2);
+        intTree.insert(12);
+        intTree.insert(1);
+        intTree.insert(7);
+        intTree.insert(14);
+
+        Consumer printer = element -> System.out.print(element + " ");
+
+        System.out.println("Height: " + intTree.height());
+
+        System.out.print("\nIn-order traversal: ");
+        intTree.inOrderTraversal(printer);
+
+        System.out.print("\nPre-order traversal: ");
+        intTree.preOrderTraversal(printer);
+
+        System.out.print("\nPost-order traversal: ");
+        intTree.postOrderTraversal(printer);
+        System.out.println();
+
+    }
+
+
+}

binary-search-tree/src/main/java/bobocode/Node.java

@@ -0,0 +1,35 @@
+package bobocode;
+
+public class Node<T> {
+    private T element;
+    Node<T> left;
+    Node<T> right;
+
+    public Node(T element) {
+        this.element = element;
+    }
+
+    public T getElement() {
+        return element;
+    }
+
+    public void setElement(T element) {
+        this.element = element;
+    }
+
+    public Node<T> getLeft() {
+        return left;
+    }
+
+    public void setLeft(Node<T> left) {
+        this.left = left;
+    }
+
+    public Node<T> getRight() {
+        return right;
+    }
+
+    public void setRight(Node<T> right) {
+        this.right = right;
+    }
+}

function-factory-task/pom.xml

@@ -0,0 +1,16 @@
+<?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>
+
+    <parent>
+        <artifactId>java-8-parent</artifactId>
+        <groupId>com.bobocode</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>function-factory-task</artifactId>
+
+    
+</project>

function-factory-task/src/main/java/com/bobocode/FunctionFactoryTask.java

@@ -0,0 +1,67 @@
+package com.bobocode;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+/**
+ * FunctionFactory is an API that allows you to store and retrieve functions by name. Functions are stored in a HashMap,
+ * where the key is a function name, and the value is a Function<T,R> instance. Methods addFunction(), and getFunction()
+ * are already implemented.
+ * <p>
+ * The task is to create different types of functions and manage them using FunctionFactory. The instruction is placed
+ * to the main method.
+ */
+public class FunctionFactoryTask {
+
+    static class FunctionFactory<T, R> {
+        private Map<String, Function<T, R>> functionMap = new HashMap<>();
+
+        public void addFunction(String name, Function<T, R> function) {
+            functionMap.put(name, function);
+        }
+
+        public Function<T, R> getFunction(String name) {
+            if (functionMap.containsKey(name)) {
+                return functionMap.get(name);
+            } else {
+                throw new InvalidFunctionNameException(name);
+            }
+        }
+    }
+
+    static class InvalidFunctionNameException extends RuntimeException {
+        public InvalidFunctionNameException(String functionName) {
+            super("Function " + functionName + " doesn't exist.");
+        }
+    }
+
+    /**
+     * Follow the instructions to finish the task
+     */
+    public static void main(String[] args) {
+        FunctionFactory<Integer, Integer> functionFactory = new FunctionFactory<>();
+        // 1. add simple functions "square", "increment", "decrement", "negative"
+        // 2. get each function by name, and apply to argument 5, print a result (should be 25, 6, 4,-5 accordingly)
+        // 3. add simple function "abs" using method reference (use class Math)
+        // 4. add try/catch block, catch InvalidFunctionNameException and print some error message to the console
+        // 5. try to get function with invalid name
+
+        functionFactory.addFunction("square", n -> n * n);
+        functionFactory.addFunction("abs", Math::abs);
+
+        functionFactory.getFunction("square").apply(5);
+        try{
+            functionFactory.getFunction("abs").apply(5);
+        }catch (InvalidFunctionNameException e){
+            System.out.println(e.getMessage());
+        }
+
+
+
+
+    }
+
+}
+
+

lambda-basics/pom.xml

@@ -0,0 +1,16 @@
+<?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>
+
+    <parent>
+        <artifactId>java-8-parent</artifactId>
+        <groupId>com.bobocode</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>lambda-basics</artifactId>
+
+    
+</project>

lambda-basics/src/main/java/com/bobocode/LambdaExample_01.java

@@ -0,0 +1,43 @@
+package com.bobocode;
+
+import com.bobocode.model.Account;
+import com.bobocode.util.TestDataProvider;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.Period;
+import java.util.List;
+
+/**
+ * Parameterization in old Java version.
+ *
+ * This is a typical example of Java code before version 8. The first class citizens in Java are objects.
+ * Therefore we always pass as methods arguments only primitive values, and objects. In other words, we add methods
+ * parameters to make methods more universal. But what if we need to parameterize the behavior? What if we need to
+ * perform different operations on account list basing on different conditions? That's called behavior parameterization.
+ *
+ * Behavior parameterization can be achieved by passing some function as methods parameter, but Java does not allow us
+ * to pass functions as method parameters. Does it?
+ *
+ * Let's try to solve this problem with old Java style. We can not pass a function, but we can create an interface
+ * with one method, and then pass its anonymous implementation with required logic. That's much more flexible right?
+ *
+ * See LambdaExample_02.java
+ *
+ * */
+public class LambdaExample_01 {
+    public static void main(String[] args) {
+        List<Account> accounts = TestDataProvider.generateAccountList();
+        giveBonusForLoyalClients(accounts, 4, BigDecimal.valueOf(50));
+    }
+
+    private static void giveBonusForLoyalClients(List<Account> accounts, int yearsWithBank, BigDecimal bonus) {
+        for (Account account : accounts) {
+            // todo: HARD CODED condition should be passed as method argument
+            if (Period.between(account.getCreationDate(), LocalDate.now()).getYears() >= yearsWithBank) {
+                // todo: HARD CODED operation should be passed as method argument
+                account.setBalance(account.getBalance().add(bonus));
+            }
+        }
+    }
+}