Fix conflicts in librarie/pom.xml

.gitignore

@@ -41,4 +41,5 @@ SpringDataInjectionDemo/.mvn/wrapper/maven-wrapper.properties
 spring-call-getters-using-reflection/.mvn/wrapper/maven-wrapper.properties
 
 spring-check-if-a-property-is-null/.mvn/wrapper/maven-wrapper.properties
-/vertx-and-rxjava/.vertx/
+*.springBeans
+

README.md

@@ -23,4 +23,4 @@ Any IDE can be used to work with the projects, but if you're using Eclipse, cons
 
 CI - Jenkins
 ================================
-This tutorials project is being built **[>> HERE](https://rest-security.ci.cloudbees.com/job/tutorials/)**
+This tutorials project is being built **[>> HERE](https://rest-security.ci.cloudbees.com/job/github%20projects%20Jobs/job/tutorials/)**

algorithms/src/main/java/com/baeldung/algorithms/binarysearch/BinarySearch.java

@@ -1,3 +1,5 @@
+package com.baeldung.algorithms.binarysearch;
+
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForce.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionBruteForce {
+
+    public static <T> boolean detectCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Node<T> it1 = head;
+        int nodesTraversedByOuter = 0;
+        while (it1 != null && it1.next != null) {
+            it1 = it1.next;
+            nodesTraversedByOuter++;
+
+            int x = nodesTraversedByOuter;
+            Node<T> it2 = head;
+            int noOfTimesCurrentNodeVisited = 0;
+
+            while (x > 0) {
+                it2 = it2.next;
+
+                if (it2 == it1) {
+                    noOfTimesCurrentNodeVisited++;
+                }
+
+                if (noOfTimesCurrentNodeVisited == 2) {
+                    return true;
+                }
+
+                x--;
+            }
+        }
+
+        return false;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIterators.java

@@ -0,0 +1,25 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionByFastAndSlowIterators {
+
+    public static <T> boolean detectCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Node<T> slow = head;
+        Node<T> fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow == fast) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashing.java

@@ -0,0 +1,27 @@
+package com.baeldung.algorithms.linkedlist;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class CycleDetectionByHashing {
+
+    public static <T> boolean detectCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Set<Node<T>> set = new HashSet<>();
+        Node<T> node = head;
+
+        while (node != null) {
+            if (set.contains(node)) {
+                return true;
+            }
+            set.add(node);
+            node = node.next;
+        }
+
+        return false;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForce.java

@@ -0,0 +1,61 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalBruteForce {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Node<T> slow = head;
+        Node<T> fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow == fast) {
+                removeCycle(slow, head);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
+        Node<T> it = head;
+
+        while (it != null) {
+            if (isNodeReachableFromLoopNode(it, loopNodeParam)) {
+                Node<T> loopStart = it;
+                findEndNodeAndBreakCycle(loopStart);
+                break;
+            }
+            it = it.next;
+        }
+    }
+
+    private static <T> boolean isNodeReachableFromLoopNode(Node<T> it, Node<T> loopNodeParam) {
+        Node<T> loopNode = loopNodeParam;
+
+        while (loopNode.next != loopNodeParam) {
+            if (it == loopNode) {
+                return true;
+            }
+            loopNode = loopNode.next;
+        }
+
+        return false;
+    }
+
+    private static <T> void findEndNodeAndBreakCycle(Node<T> loopStartParam) {
+        Node<T> loopStart = loopStartParam;
+
+        while (loopStart.next != loopStartParam) {
+            loopStart = loopStart.next;
+        }
+
+        loopStart.next = null;
+    }
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodes.java

@@ -0,0 +1,55 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalByCountingLoopNodes {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Node<T> slow = head;
+        Node<T> fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow == fast) {
+                int cycleLength = calculateCycleLength(slow);
+                removeCycle(head, cycleLength);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static <T> void removeCycle(Node<T> head, int cycleLength) {
+        Node<T> cycleLengthAdvancedIterator = head;
+        Node<T> it = head;
+
+        for (int i = 0; i < cycleLength; i++) {
+            cycleLengthAdvancedIterator = cycleLengthAdvancedIterator.next;
+        }
+
+        while (it.next != cycleLengthAdvancedIterator.next) {
+            it = it.next;
+            cycleLengthAdvancedIterator = cycleLengthAdvancedIterator.next;
+        }
+
+        cycleLengthAdvancedIterator.next = null;
+    }
+
+    private static <T> int calculateCycleLength(Node<T> loopNodeParam) {
+        Node<T> loopNode = loopNodeParam;
+        int length = 1;
+
+        while (loopNode.next != loopNodeParam) {
+            length++;
+            loopNode = loopNode.next;
+        }
+
+        return length;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodes.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalWithoutCountingLoopNodes {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        if (head == null) {
+            return false;
+        }
+
+        Node<T> slow = head;
+        Node<T> fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow == fast) {
+                removeCycle(slow, head);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static <T> void removeCycle(Node<T> meetingPointParam, Node<T> head) {
+        Node<T> loopNode = meetingPointParam;
+        Node<T> it = head;
+
+        while (loopNode.next != it.next) {
+            it = it.next;
+            loopNode = loopNode.next;
+        }
+
+        loopNode.next = null;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/linkedlist/Node.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class Node<T> {
+    T data;
+    Node<T> next;
+
+    public static <T> Node<T> createNewNode(T data, Node<T> next) {
+        Node<T> node = new Node<T>();
+        node.data = data;
+        node.next = next;
+        return node;
+    }
+
+    public static <T> void traverseList(Node<T> root) {
+        if (root == null) {
+            return;
+        }
+
+        Node<T> node = root;
+        while (node != null) {
+            System.out.println(node.data);
+            node = node.next;
+        }
+    }
+
+    public static <T> Node<T> getTail(Node<T> root) {
+        if (root == null) {
+            return null;
+        }
+
+        Node<T> node = root;
+        while (node.next != null) {
+            node = node.next;
+        }
+        return node;
+    }
+
+}

algorithms/src/test/java/algorithms/binarysearch/BinarySearchTest.java

@@ -1,9 +1,11 @@
+package algorithms.binarysearch;
+
 import java.util.Arrays;
 import java.util.List;
 
 import org.junit.Assert;
 import org.junit.Test;
-
+import com.baeldung.algorithms.binarysearch.BinarySearch;
 
 public class BinarySearchTest {
 

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForceTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleDetectionBruteForceTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleDetectionBruteForce.detectCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleDetectionBruteForce.detectCycle(root));
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIteratorsTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleDetectionByFastAndSlowIteratorsTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashingTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleDetectionByHashingTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleDetectionByHashing.detectCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleDetectionByHashing.detectCycle(root));
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionTestBase.java

@@ -0,0 +1,27 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionTestBase {
+
+    public static Node<Integer> createList() {
+        Node<Integer> root = Node.createNewNode(10, null);
+
+        for (int i = 9; i >= 1; --i) {
+            Node<Integer> current = Node.createNewNode(i, root);
+            root = current;
+        }
+
+        return root;
+    }
+
+    public static void createLoop(Node<Integer> root) {
+        Node<Integer> tail = Node.getTail(root);
+
+        Node<Integer> middle = root;
+        for (int i = 1; i <= 4; i++) {
+            middle = middle.next;
+        }
+
+        tail.next = middle;
+    }
+
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForceTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleRemovalBruteForceTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleRemovalBruteForce.detectAndRemoveCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectAndRemoveLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleRemovalBruteForce.detectAndRemoveCycle(root));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodesTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleRemovalByCountingLoopNodesTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleRemovalByCountingLoopNodes.detectAndRemoveCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectAndRemoveLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleRemovalByCountingLoopNodes.detectAndRemoveCycle(root));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodesTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CycleRemovalWithoutCountingLoopNodesTest extends CycleDetectionTestBase {
+
+    @Test
+    public void givenNormalList_dontDetectLoop() {
+        Node<Integer> root = createList();
+        Assert.assertFalse(CycleRemovalWithoutCountingLoopNodes.detectAndRemoveCycle(root));
+    }
+
+    @Test
+    public void givenCyclicList_detectAndRemoveLoop() {
+        Node<Integer> root = createList();
+        createLoop(root);
+        Assert.assertTrue(CycleRemovalWithoutCountingLoopNodes.detectAndRemoveCycle(root));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    }
+}

core-java-8/.gitignore

@@ -0,0 +1,26 @@
+*.class
+
+0.*
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+.resourceCache
+
+# Packaged files #
+*.jar
+*.war
+*.ear
+
+# Files generated by integration tests
+*.txt
+backup-pom.xml
+/bin/
+/temp
+
+#IntelliJ specific
+.idea/
+*.iml

core-java-8/README.md

@@ -0,0 +1,32 @@
+=========
+
+## Core Java 8 Cookbooks and Examples
+
+### Relevant Articles: 
+- [Java 8 Collectors](http://www.baeldung.com/java-8-collectors)
+- [Guide to Java 8’s Functional Interfaces](http://www.baeldung.com/java-8-functional-interfaces)
+- [Java 8 – Powerful Comparison with Lambdas](http://www.baeldung.com/java-8-sort-lambda)
+- [Java 8 New Features](http://www.baeldung.com/java-8-new-features)
+- [Lambda Expressions and Functional Interfaces: Tips and Best Practices](http://www.baeldung.com/java-8-lambda-expressions-tips)
+- [The Double Colon Operator in Java 8](http://www.baeldung.com/java-8-double-colon-operator)
+- [Java 8 Streams Advanced](http://www.baeldung.com/java-8-streams)
+- [Introduction to Java 8 Streams](http://www.baeldung.com/java-8-streams-introduction)
+- [Guide to Java 8 groupingBy Collector](http://www.baeldung.com/java-groupingby-collector)
+- [Strategy Design Pattern in Java 8](http://www.baeldung.com/java-strategy-pattern)
+- [Java 8 and Infinite Streams](http://www.baeldung.com/java-inifinite-streams)
+- [String Operations with Java Streams](http://www.baeldung.com/java-stream-operations-on-strings)
+- [Exceptions in Java 8 Lambda Expressions](http://www.baeldung.com/java-lambda-exceptions)
+- [Java 8 Stream findFirst() vs. findAny()](http://www.baeldung.com/java-stream-findfirst-vs-findany)
+- [Guide to Java 8 Comparator.comparing()](http://www.baeldung.com/java-8-comparator-comparing)
+- [How to Get the Last Element of a Stream in Java?](http://www.baeldung.com/java-stream-last-element)
+- [Introduction to the Java 8 Date/Time API](http://www.baeldung.com/java-8-date-time-intro)
+- [Migrating to the New Java 8 Date Time API](http://www.baeldung.com/migrating-to-java-8-date-time-api)
+- [Guide To Java 8 Optional](http://www.baeldung.com/java-optional)
+- [Guide to the Java 8 forEach](http://www.baeldung.com/foreach-java)
+- [Get the Current Date, Time and Timestamp in Java 8](http://www.baeldung.com/current-date-time-and-timestamp-in-java-8)
+- [TemporalAdjuster in Java](http://www.baeldung.com/java-temporal-adjuster)
+- [Finding Max/Min of a List or Collection](http://www.baeldung.com/java-collection-min-max)
+- [Java Base64 Encoding and Decoding](http://www.baeldung.com/java-base64-encode-and-decode)
+- [The Difference Between map() and flatMap()](http://www.baeldung.com/java-difference-map-and-flatmap)
+
+- [Merging Streams in Java](http://www.baeldung.com/java-merge-streams)

core-java-8/pom.xml

@@ -0,0 +1,258 @@
+<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>com.baeldung</groupId>
+    <artifactId>core-java-8</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <name>core-java-8</name>
+
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+
+        <!-- utils -->
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>${commons-collections4.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>${commons-io.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${commons-math3.version}</version>
+        </dependency>
+
+       <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>1.2.17</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>        
+
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        
+        <!-- test scoped -->
+
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.jayway.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>${avaitility.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <finalName>core-java-8</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>copy-dependencies</id>
+                        <phase>prepare-package</phase>
+                        <goals>
+                            <goal>copy-dependencies</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <addClasspath>true</addClasspath>
+                            <classpathPrefix>libs/</classpathPrefix>
+                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                        </manifest>
+                    </archive>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                        <configuration>
+                            <archiveBaseDirectory>${project.basedir}</archiveBaseDirectory>
+                            <archive>
+                                <manifest>
+                                    <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                                </manifest>
+                            </archive>
+                            <descriptorRefs>
+                                <descriptorRef>jar-with-dependencies</descriptorRef>
+                            </descriptorRefs>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <shadedArtifactAttached>true</shadedArtifactAttached>
+                            <transformers>
+                                <transformer
+                                    implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                    <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                                </transformer>
+                            </transformers>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>com.jolira</groupId>
+                <artifactId>onejar-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <configuration>
+                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <attachToBuild>true</attachToBuild>
+                            <filename>${project.build.finalName}-onejar.${project.packaging}</filename>
+                        </configuration>
+                        <goals>
+                            <goal>one-jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                        <configuration>
+                            <classifier>spring-boot</classifier>
+                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+
+    </build>
+
+    <profiles>
+        <profile>
+            <id>integration</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-surefire-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <phase>integration-test</phase>
+                                <goals>
+                                    <goal>test</goal>
+                                </goals>
+                                <configuration>
+                                    <excludes>
+                                        <exclude>**/*ManualTest.java</exclude>
+                                    </excludes>
+                                    <includes>
+                                        <include>**/*IntegrationTest.java</include>
+                                    </includes>
+                                </configuration>
+                            </execution>
+                        </executions>
+                        <configuration>
+                            <systemPropertyVariables>
+                                <test.mime>json</test.mime>
+                            </systemPropertyVariables>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+    
+    <properties>
+
+        <!-- util -->
+        <guava.version>21.0</guava.version>
+        <commons-lang3.version>3.5</commons-lang3.version>
+        <commons-math3.version>3.6.1</commons-math3.version>
+        <commons-io.version>2.5</commons-io.version>
+        <commons-collections4.version>4.1</commons-collections4.version>
+        <collections-generic.version>4.01</collections-generic.version>
+        <commons-codec.version>1.10</commons-codec.version>
+        <lombok.version>1.16.12</lombok.version>
+
+        <!-- testing -->
+        <assertj.version>3.6.1</assertj.version>
+        <avaitility.version>1.7.0</avaitility.version>
+
+    </properties>
+</project>

core-java-8/src/main/java/com/baeldung/AdderImpl.java

@@ -1,5 +1,6 @@
 package com.baeldung;
 
+
 import java.util.function.Consumer;
 import java.util.function.Function;
 

core-java-8/src/main/java/com/baeldung/Bar.java

@@ -1,5 +1,6 @@
 package com.baeldung;
 
+
 @FunctionalInterface
 public interface Bar {
 

core-java-8/src/main/java/com/baeldung/Baz.java

@@ -1,5 +1,6 @@
 package com.baeldung;
 
+
 @FunctionalInterface
 public interface Baz {
 

core-java-8/src/main/java/com/baeldung/Foo.java

@@ -1,5 +1,6 @@
 package com.baeldung;
 
+
 @FunctionalInterface
 public interface Foo {
 

core-java-8/src/main/java/com/baeldung/FooExtended.java

@@ -1,5 +1,6 @@
 package com.baeldung;
 
+
 @FunctionalInterface
 public interface FooExtended extends Baz, Bar {
 

core-java-8/src/main/java/com/baeldung/UseFoo.java

@@ -1,5 +1,6 @@
 package com.baeldung;
 
+
 import java.util.function.Function;
 
 public class UseFoo {

core-java-8/src/main/java/com/baeldung/datetime/UseLocalDateTime.java

@@ -0,0 +1,11 @@
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+
+public class UseLocalDateTime {
+
+    public LocalDateTime getLocalDateTimeUsingParseMethod(String representation) {
+        return LocalDateTime.parse(representation);
+    }
+
+}

core-java-8/src/test/java/com/baeldung/java8/JavaTryWithResourcesLongRunningUnitTest.java

@@ -1,20 +1,19 @@
 package com.baeldung.java8;
 
-import org.junit.Assert;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.Date;
 import java.util.Scanner;
 
+import org.junit.Assert;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 public class JavaTryWithResourcesLongRunningUnitTest {
 
     private static final Logger LOG = LoggerFactory.getLogger(JavaTryWithResourcesLongRunningUnitTest.class);
 
-
     private static final String TEST_STRING_HELLO_WORLD = "Hello World";
     private Date resource1Date, resource2Date;
 
@@ -28,7 +27,8 @@ public class JavaTryWithResourcesLongRunningUnitTest {
             pw.print(TEST_STRING_HELLO_WORLD);
         }
 
-        Assert.assertEquals(sw.getBuffer().toString(), TEST_STRING_HELLO_WORLD);
+        Assert.assertEquals(sw.getBuffer()
+            .toString(), TEST_STRING_HELLO_WORLD);
     }
 
     /* Example for using multiple resources */
@@ -42,7 +42,8 @@ public class JavaTryWithResourcesLongRunningUnitTest {
             }
         }
 
-        Assert.assertEquals(sw.getBuffer().toString(), TEST_STRING_HELLO_WORLD);
+        Assert.assertEquals(sw.getBuffer()
+            .toString(), TEST_STRING_HELLO_WORLD);
     }
 
     /* Example to show order in which the resources are closed */
@@ -88,4 +89,4 @@ public class JavaTryWithResourcesLongRunningUnitTest {
         }
     }
 
-}
+}