Merge pull request #14 from eugenp/master

getting latest

.gitignore

@@ -19,6 +19,7 @@
 .idea/
 *.iml
 *.iws
+out/
 
 # Mac
 .DS_Store
@@ -27,6 +28,9 @@
 log/
 target/
 
+# Gradle
+.gradle/
+
 spring-openid/src/main/resources/application.properties
 .recommenders/
 /spring-hibernate4/nbproject/
@@ -72,4 +76,5 @@ persistence-modules/hibernate5/transaction.log
 apache-avro/src/main/java/com/baeldung/avro/model/
 jta/transaction-logs/
 software-security/sql-injection-samples/derby.log
-spring-soap/src/main/java/com/baeldung/springsoap/gen/
+spring-soap/src/main/java/com/baeldung/springsoap/gen/
+/report-*.json

README.md

@@ -20,17 +20,22 @@ In additional to Spring, the following technologies are in focus: `core Java`, `
 
 Building the project
 ====================
-To do the full build, do: `mvn install -Pdefault -Dgib.enabled=false`
+To do the full build, do: `mvn clean install`
 
 
 Building a single module
 ====================
-To build a specific module run the command: `mvn clean install -Dgib.enabled=false` in the module directory
+To build a specific module run the command: `mvn clean install` in the module directory
 
 
 Running a Spring Boot module
 ====================
-To run a Spring Boot module run the command: `mvn spring-boot:run -Dgib.enabled=false` in the module directory
+To run a Spring Boot module run the command: `mvn spring-boot:run` in the module directory
+
+#Running Tests
+
+The command `mvn clean install` will run the unit tests in a module.
+To run the integration tests, use the command `mvn clean install -Pintegration-lite-first`
 
 
 

akka-streams/pom.xml

@@ -14,18 +14,19 @@
     <dependencies>
         <dependency>
             <groupId>com.typesafe.akka</groupId>
-            <artifactId>akka-stream_2.11</artifactId>
+            <artifactId>akka-stream_${scala.version}</artifactId>
             <version>${akkastreams.version}</version>
         </dependency>
         <dependency>
             <groupId>com.typesafe.akka</groupId>
-            <artifactId>akka-stream-testkit_2.11</artifactId>
+            <artifactId>akka-stream-testkit_${scala.version}</artifactId>
             <version>${akkastreams.version}</version>
         </dependency>
     </dependencies>
 
     <properties>
         <akkastreams.version>2.5.2</akkastreams.version>
+        <scala.version>2.11</scala.version>
     </properties>
 
 </project>

algorithms-miscellaneous-1/README.md

@@ -14,6 +14,5 @@
 - [Calculate Factorial in Java](https://www.baeldung.com/java-calculate-factorial)
 - [Find Substrings That Are Palindromes in Java](https://www.baeldung.com/java-palindrome-substrings)
 - [Find the Longest Substring without Repeating Characters](https://www.baeldung.com/java-longest-substring-without-repeated-characters)
-- [Java Two Pointer Technique](https://www.baeldung.com/java-two-pointer-technique)
 - [Permutations of an Array in Java](https://www.baeldung.com/java-array-permutations)
-- [Implementing Simple State Machines with Java Enums](https://www.baeldung.com/java-enum-simple-state-machine)
+- [Generate Combinations in Java](https://www.baeldung.com/java-combinations-algorithm)

algorithms-miscellaneous-1/pom.xml

@@ -39,6 +39,11 @@
             <version>${org.assertj.core.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.github.dpaukov</groupId>
+            <artifactId>combinatoricslib3</artifactId>
+            <version>3.3.0</version>
+         </dependency>
     </dependencies>
 
     <build>
@@ -77,7 +82,7 @@
         <commons-math3.version>3.6.1</commons-math3.version>
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
         <commons-codec.version>1.11</commons-codec.version>
-        <guava.version>25.1-jre</guava.version>
+        <guava.version>27.0.1-jre</guava.version>
     </properties>
 
 </project>

algorithms-miscellaneous-2/README.md

@@ -8,9 +8,6 @@
 - [Create a Sudoku Solver in Java](http://www.baeldung.com/java-sudoku)
 - [Displaying Money Amounts in Words](http://www.baeldung.com/java-money-into-words)
 - [A Collaborative Filtering Recommendation System in Java](http://www.baeldung.com/java-collaborative-filtering-recommendations)
-- [Converting Between Roman and Arabic Numerals in Java](http://www.baeldung.com/java-convert-roman-arabic)
-- [Practical Java Examples of the Big O Notation](http://www.baeldung.com/java-algorithm-complexity)
-- [An Introduction to the Theory of Big-O Notation](http://www.baeldung.com/big-o-notation)
 - [Check If Two Rectangles Overlap In Java](https://www.baeldung.com/java-check-if-two-rectangles-overlap)
 - [Calculate the Distance Between Two Points in Java](https://www.baeldung.com/java-distance-between-two-points)
 - [Find the Intersection of Two Lines in Java](https://www.baeldung.com/java-intersection-of-two-lines)
@@ -18,3 +15,5 @@
 - [Calculate Percentage in Java](https://www.baeldung.com/java-calculate-percentage)
 - [Converting Between Byte Arrays and Hexadecimal Strings in Java](https://www.baeldung.com/java-byte-arrays-hex-strings)
 - [Convert Latitude and Longitude to a 2D Point in Java](https://www.baeldung.com/java-convert-latitude-longitude)
+- [Reversing a Binary Tree in Java](https://www.baeldung.com/java-reversing-a-binary-tree)
+- [Find If Two Numbers Are Relatively Prime in Java](https://www.baeldung.com/java-two-relatively-prime-numbers)

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/relativelyprime/RelativelyPrime.java

@@ -0,0 +1,45 @@
+package com.baeldung.algorithms.relativelyprime;
+
+import java.math.BigInteger;
+
+class RelativelyPrime {
+
+    static boolean iterativeRelativelyPrime(int a, int b) {
+        return iterativeGCD(a, b) == 1;
+    }
+
+    static boolean recursiveRelativelyPrime(int a, int b) {
+        return recursiveGCD(a, b) == 1;
+    }
+
+    static boolean bigIntegerRelativelyPrime(int a, int b) {
+        return BigInteger.valueOf(a).gcd(BigInteger.valueOf(b)).equals(BigInteger.ONE);
+    }
+
+    private static int iterativeGCD(int a, int b) {
+        int tmp;
+        while (b != 0) {
+            if (a < b) {
+                tmp = a;
+                a = b;
+                b = tmp;
+            }
+            tmp = b;
+            b = a % b;
+            a = tmp;
+        }
+        return a;
+    }
+
+    private static int recursiveGCD(int a, int b) {
+        if (b == 0) {
+            return a;
+        }
+        if (a < b) {
+            return recursiveGCD(b, a);
+        }
+        return recursiveGCD(b, a % b);
+    }
+
+
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/reversingtree/TreeNode.java

@@ -0,0 +1,42 @@
+package com.baeldung.algorithms.reversingtree;
+
+public class TreeNode {
+
+    private int value;
+    private TreeNode rightChild;
+    private TreeNode leftChild;
+
+    public int getValue() {
+        return value;
+    }
+
+    public void setValue(int value) {
+        this.value = value;
+    }
+
+    public TreeNode getRightChild() {
+        return rightChild;
+    }
+
+    public void setRightChild(TreeNode rightChild) {
+        this.rightChild = rightChild;
+    }
+
+    public TreeNode getLeftChild() {
+        return leftChild;
+    }
+
+    public void setLeftChild(TreeNode leftChild) {
+        this.leftChild = leftChild;
+    }
+
+    public TreeNode(int value, TreeNode leftChild, TreeNode rightChild) {
+        this.value = value;
+        this.rightChild = rightChild;
+        this.leftChild = leftChild;
+    }
+
+    public TreeNode(int value) {
+        this.value = value;
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/reversingtree/TreeReverser.java

@@ -0,0 +1,53 @@
+package com.baeldung.algorithms.reversingtree;
+
+import java.util.LinkedList;
+
+public class TreeReverser {
+
+    public void reverseRecursive(TreeNode treeNode) {
+        if (treeNode == null) {
+            return;
+        }
+
+        TreeNode temp = treeNode.getLeftChild();
+        treeNode.setLeftChild(treeNode.getRightChild());
+        treeNode.setRightChild(temp);
+
+        reverseRecursive(treeNode.getLeftChild());
+        reverseRecursive(treeNode.getRightChild());
+    }
+
+    public void reverseIterative(TreeNode treeNode) {
+        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
+
+        if (treeNode != null) {
+            queue.add(treeNode);
+        }
+
+        while (!queue.isEmpty()) {
+
+            TreeNode node = queue.poll();
+            if (node.getLeftChild() != null)
+                queue.add(node.getLeftChild());
+            if (node.getRightChild() != null)
+                queue.add(node.getRightChild());
+
+            TreeNode temp = node.getLeftChild();
+            node.setLeftChild(node.getRightChild());
+            node.setRightChild(temp);
+        }
+    }
+
+    public String toString(TreeNode root) {
+        if (root == null) {
+            return "";
+        }
+
+        StringBuffer buffer = new StringBuffer(String.valueOf(root.getValue())).append(" ");
+
+        buffer.append(toString(root.getLeftChild()));
+        buffer.append(toString(root.getRightChild()));
+
+        return buffer.toString();
+    }
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/relativelyprime/RelativelyPrimeUnitTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.algorithms.relativelyprime;
+
+import org.junit.Test;
+
+import static com.baeldung.algorithms.relativelyprime.RelativelyPrime.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RelativelyPrimeUnitTest {
+
+    @Test
+    public void givenNonRelativelyPrimeNumbers_whenCheckingIteratively_shouldReturnFalse() {
+
+        boolean result = iterativeRelativelyPrime(45, 35);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenRelativelyPrimeNumbers_whenCheckingIteratively_shouldReturnTrue() {
+
+        boolean result = iterativeRelativelyPrime(500, 501);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenNonRelativelyPrimeNumbers_whenCheckingRecursively_shouldReturnFalse() {
+
+        boolean result = recursiveRelativelyPrime(45, 35);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenRelativelyPrimeNumbers_whenCheckingRecursively_shouldReturnTrue() {
+
+        boolean result = recursiveRelativelyPrime(500, 501);
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenNonRelativelyPrimeNumbers_whenCheckingUsingBigIntegers_shouldReturnFalse() {
+
+        boolean result = bigIntegerRelativelyPrime(45, 35);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenRelativelyPrimeNumbers_whenCheckingBigIntegers_shouldReturnTrue() {
+
+        boolean result = bigIntegerRelativelyPrime(500, 501);
+        assertThat(result).isTrue();
+    }
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/reversingtree/TreeReverserUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.algorithms.reversingtree;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class TreeReverserUnitTest {
+
+    @Test
+    public void givenTreeWhenReversingRecursivelyThenReversed() {
+        TreeReverser reverser = new TreeReverser();
+
+        TreeNode treeNode = createBinaryTree();
+
+        reverser.reverseRecursive(treeNode);
+
+        assertEquals("4 7 9 6 2 3 1", reverser.toString(treeNode)
+            .trim());
+    }
+
+    @Test
+    public void givenTreeWhenReversingIterativelyThenReversed() {
+        TreeReverser reverser = new TreeReverser();
+
+        TreeNode treeNode = createBinaryTree();
+
+        reverser.reverseIterative(treeNode);
+
+        assertEquals("4 7 9 6 2 3 1", reverser.toString(treeNode)
+            .trim());
+    }
+
+    private TreeNode createBinaryTree() {
+
+        TreeNode leaf1 = new TreeNode(1);
+        TreeNode leaf2 = new TreeNode(3);
+        TreeNode leaf3 = new TreeNode(6);
+        TreeNode leaf4 = new TreeNode(9);
+
+        TreeNode nodeRight = new TreeNode(7, leaf3, leaf4);
+        TreeNode nodeLeft = new TreeNode(2, leaf1, leaf2);
+
+        TreeNode root = new TreeNode(4, nodeLeft, nodeRight);
+
+        return root;
+    }
+}

algorithms-miscellaneous-3/.gitignore

@@ -0,0 +1,4 @@
+/target/
+.settings/
+.classpath
+.project

algorithms-miscellaneous-3/README.md

@@ -0,0 +1,6 @@
+## Relevant articles:
+
+- [Java Two Pointer Technique](https://www.baeldung.com/java-two-pointer-technique)
+- [Implementing Simple State Machines with Java Enums](https://www.baeldung.com/java-enum-simple-state-machine)
+- [Converting Between Roman and Arabic Numerals in Java](http://www.baeldung.com/java-convert-roman-arabic)
+- [Practical Java Examples of the Big O Notation](http://www.baeldung.com/java-algorithm-complexity)

algorithms-miscellaneous-3/pom.xml

@@ -0,0 +1,39 @@
+<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>
+    <artifactId>algorithms-miscellaneous-3</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>algorithms-miscellaneous-3</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${org.assertj.core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.codehaus.mojo</groupId>
+                    <artifactId>exec-maven-plugin</artifactId>
+                    <version>${exec-maven-plugin.version}</version>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+
+    <properties>
+        <org.assertj.core.version>3.9.0</org.assertj.core.version>
+    </properties>
+
+</project>

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/graphcycledetection/domain/Graph.java

@@ -0,0 +1,51 @@
+package com.baeldung.algorithms.graphcycledetection.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Graph {
+
+    private List<Vertex> vertices;
+
+    public Graph() {
+        this.vertices = new ArrayList<>();
+    }
+
+    public Graph(List<Vertex> vertices) {
+        this.vertices = vertices;
+    }
+
+    public void addVertex(Vertex vertex) {
+        this.vertices.add(vertex);
+    }
+
+    public void addEdge(Vertex from, Vertex to) {
+        from.addNeighbour(to);
+    }
+
+    public boolean hasCycle() {
+        for (Vertex vertex : vertices) {
+            if (!vertex.isVisited() && hasCycle(vertex)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean hasCycle(Vertex sourceVertex) {
+        sourceVertex.setBeingVisited(true);
+
+        for (Vertex neighbour : sourceVertex.getAdjacencyList()) {
+            if (neighbour.isBeingVisited()) {
+                // backward edge exists
+                return true;
+            } else if (!neighbour.isVisited() && hasCycle(neighbour)) {
+                return true;
+            }
+        }
+
+        sourceVertex.setBeingVisited(false);
+        sourceVertex.setVisited(true);
+        return false;
+    }
+}

algorithms-miscellaneous-3/src/main/java/com/baeldung/algorithms/graphcycledetection/domain/Vertex.java

@@ -0,0 +1,56 @@
+package com.baeldung.algorithms.graphcycledetection.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Vertex {
+
+    private String label;
+
+    private boolean visited;
+
+    private boolean beingVisited;
+
+    private List<Vertex> adjacencyList;
+
+    public Vertex(String label) {
+        this.label = label;
+        this.adjacencyList = new ArrayList<>();
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+
+    public boolean isVisited() {
+        return visited;
+    }
+
+    public void setVisited(boolean visited) {
+        this.visited = visited;
+    }
+
+    public boolean isBeingVisited() {
+        return beingVisited;
+    }
+
+    public void setBeingVisited(boolean beingVisited) {
+        this.beingVisited = beingVisited;
+    }
+
+    public List<Vertex> getAdjacencyList() {
+        return adjacencyList;
+    }
+
+    public void setAdjacencyList(List<Vertex> adjacencyList) {
+        this.adjacencyList = adjacencyList;
+    }
+
+    public void addNeighbour(Vertex adjacent) {
+        this.adjacencyList.add(adjacent);
+    }
+}

algorithms-miscellaneous-3/src/test/java/com/baeldung/algorithms/graphcycledetection/GraphCycleDetectionUnitTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.algorithms.graphcycledetection;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import com.baeldung.algorithms.graphcycledetection.domain.Graph;
+import com.baeldung.algorithms.graphcycledetection.domain.Vertex;
+
+public class GraphCycleDetectionUnitTest {
+
+    @Test
+    public void givenGraph_whenCycleExists_thenReturnTrue() {
+
+        Vertex vertexA = new Vertex("A");
+        Vertex vertexB = new Vertex("B");
+        Vertex vertexC = new Vertex("C");
+        Vertex vertexD = new Vertex("D");
+
+        Graph graph = new Graph();
+        graph.addVertex(vertexA);
+        graph.addVertex(vertexB);
+        graph.addVertex(vertexC);
+        graph.addVertex(vertexD);
+
+        graph.addEdge(vertexA, vertexB);
+        graph.addEdge(vertexB, vertexC);
+        graph.addEdge(vertexC, vertexA);
+        graph.addEdge(vertexD, vertexC);
+
+        assertTrue(graph.hasCycle());
+    }
+
+    @Test
+    public void givenGraph_whenNoCycleExists_thenReturnFalse() {
+
+        Vertex vertexA = new Vertex("A");
+        Vertex vertexB = new Vertex("B");
+        Vertex vertexC = new Vertex("C");
+        Vertex vertexD = new Vertex("D");
+
+        Graph graph = new Graph();
+        graph.addVertex(vertexA);
+        graph.addVertex(vertexB);
+        graph.addVertex(vertexC);
+        graph.addVertex(vertexD);
+
+        graph.addEdge(vertexA, vertexB);
+        graph.addEdge(vertexB, vertexC);
+        graph.addEdge(vertexA, vertexC);
+        graph.addEdge(vertexD, vertexC);
+
+        assertFalse(graph.hasCycle());
+    }
+}