Fix conflicts in libraries/pom.xml

algorithms/README.md

@@ -8,3 +8,4 @@
 - [Check If a Number Is Prime in Java](http://www.baeldung.com/java-prime-numbers)
 - [Example of Hill Climbing Algorithm](http://www.baeldung.com/java-hill-climbing-algorithm)
 - [Monte Carlo Tree Search for Tic-Tac-Toe Game](http://www.baeldung.com/java-monte-carlo-tree-search)
+- [String Search Algorithms for Large Texts](http://www.baeldung.com/java-full-text-search-algorithms)

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

@@ -2,9 +2,9 @@ package com.baeldung.algorithms.linkedlist;
 
 public class CycleDetectionBruteForce {
 
-    public static <T> boolean detectCycle(Node<T> head) {
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
         if (head == null) {
-            return false;
+            return new CycleDetectionResult<>(false, null);
         }
 
         Node<T> it1 = head;
@@ -25,14 +25,14 @@ public class CycleDetectionBruteForce {
                 }
 
                 if (noOfTimesCurrentNodeVisited == 2) {
-                    return true;
+                    return new CycleDetectionResult<>(true, it1);
                 }
 
                 x--;
             }
         }
 
-        return false;
+        return new CycleDetectionResult<>(false, null);
     }
 
 }

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

@@ -2,9 +2,9 @@ package com.baeldung.algorithms.linkedlist;
 
 public class CycleDetectionByFastAndSlowIterators {
 
-    public static <T> boolean detectCycle(Node<T> head) {
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
         if (head == null) {
-            return false;
+            return new CycleDetectionResult<>(false, null);
         }
 
         Node<T> slow = head;
@@ -15,11 +15,11 @@ public class CycleDetectionByFastAndSlowIterators {
             fast = fast.next.next;
 
             if (slow == fast) {
-                return true;
+                return new CycleDetectionResult<>(true, fast);
             }
         }
 
-        return false;
+        return new CycleDetectionResult<>(false, null);
     }
 
 }

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

@@ -5,9 +5,9 @@ import java.util.Set;
 
 public class CycleDetectionByHashing {
 
-    public static <T> boolean detectCycle(Node<T> head) {
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
         if (head == null) {
-            return false;
+            return new CycleDetectionResult<>(false, null);
         }
 
         Set<Node<T>> set = new HashSet<>();
@@ -15,13 +15,13 @@ public class CycleDetectionByHashing {
 
         while (node != null) {
             if (set.contains(node)) {
-                return true;
+                return new CycleDetectionResult<>(true, node);
             }
             set.add(node);
             node = node.next;
         }
 
-        return false;
+        return new CycleDetectionResult<>(false, null);
     }
 
 }

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

@@ -0,0 +1,12 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionResult<T> {
+    boolean cycleExists;
+    Node<T> node;
+
+    public CycleDetectionResult(boolean cycleExists, Node<T> node) {
+        super();
+        this.cycleExists = cycleExists;
+        this.node = node;
+    }
+}

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

@@ -3,26 +3,21 @@ package com.baeldung.algorithms.linkedlist;
 public class CycleRemovalBruteForce {
 
     public static <T> boolean detectAndRemoveCycle(Node<T> head) {
-        if (head == null) {
-            return false;
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
+
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
         }
 
-        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;
+        return result.cycleExists;
     }
 
+    /**
+     * @param loopNodeParam - reference to the node where Flyods cycle 
+     * finding algorithm ends, i.e. the fast and the slow iterators
+     * meet.
+     * @param head - reference to the head of the list
+     */
     private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
         Node<T> it = head;
 
@@ -39,12 +34,12 @@ public class CycleRemovalBruteForce {
     private static <T> boolean isNodeReachableFromLoopNode(Node<T> it, Node<T> loopNodeParam) {
         Node<T> loopNode = loopNodeParam;
 
-        while (loopNode.next != loopNodeParam) {
+        do {
             if (it == loopNode) {
                 return true;
             }
             loopNode = loopNode.next;
-        }
+        } while (loopNode.next != loopNodeParam);
 
         return false;
     }

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

@@ -3,28 +3,17 @@ package com.baeldung.algorithms.linkedlist;
 public class CycleRemovalByCountingLoopNodes {
 
     public static <T> boolean detectAndRemoveCycle(Node<T> head) {
-        if (head == null) {
-            return false;
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
+
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
         }
 
-        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;
+        return result.cycleExists;
     }
 
-    private static <T> void removeCycle(Node<T> head, int cycleLength) {
+    private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
+        int cycleLength = calculateCycleLength(loopNodeParam);
         Node<T> cycleLengthAdvancedIterator = head;
         Node<T> it = head;
 

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

@@ -3,24 +3,13 @@ package com.baeldung.algorithms.linkedlist;
 public class CycleRemovalWithoutCountingLoopNodes {
 
     public static <T> boolean detectAndRemoveCycle(Node<T> head) {
-        if (head == null) {
-            return false;
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
+
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
         }
 
-        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;
+        return result.cycleExists;
     }
 
     private static <T> void removeCycle(Node<T> meetingPointParam, Node<T> head) {

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

@@ -2,19 +2,22 @@ package com.baeldung.algorithms.linkedlist;
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
+@RunWith(value = Parameterized.class)
 public class CycleDetectionBruteForceTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
 
-    @Test
-    public void givenNormalList_dontDetectLoop() {
-        Node<Integer> root = createList();
-        Assert.assertFalse(CycleDetectionBruteForce.detectCycle(root));
+    public CycleDetectionBruteForceTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
     }
 
     @Test
-    public void givenCyclicList_detectLoop() {
-        Node<Integer> root = createList();
-        createLoop(root);
-        Assert.assertTrue(CycleDetectionBruteForce.detectCycle(root));
+    public void givenList_detectLoop() {
+        Assert.assertEquals(cycleExists, CycleDetectionBruteForce.detectCycle(head).cycleExists);
     }
 }

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

@@ -2,19 +2,22 @@ package com.baeldung.algorithms.linkedlist;
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
+@RunWith(value = Parameterized.class)
 public class CycleDetectionByFastAndSlowIteratorsTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
 
-    @Test
-    public void givenNormalList_dontDetectLoop() {
-        Node<Integer> root = createList();
-        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    public CycleDetectionByFastAndSlowIteratorsTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
     }
 
     @Test
-    public void givenCyclicList_detectLoop() {
-        Node<Integer> root = createList();
-        createLoop(root);
-        Assert.assertTrue(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    public void givenList_detectLoop() {
+        Assert.assertEquals(cycleExists, CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
     }
 }

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

@@ -2,19 +2,22 @@ package com.baeldung.algorithms.linkedlist;
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
+@RunWith(value = Parameterized.class)
 public class CycleDetectionByHashingTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
 
-    @Test
-    public void givenNormalList_dontDetectLoop() {
-        Node<Integer> root = createList();
-        Assert.assertFalse(CycleDetectionByHashing.detectCycle(root));
+    public CycleDetectionByHashingTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
     }
 
     @Test
-    public void givenCyclicList_detectLoop() {
-        Node<Integer> root = createList();
-        createLoop(root);
-        Assert.assertTrue(CycleDetectionByHashing.detectCycle(root));
+    public void givenList_detectLoop() {
+        Assert.assertEquals(cycleExists, CycleDetectionByHashing.detectCycle(head).cycleExists);
     }
 }

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

@@ -1,7 +1,22 @@
 package com.baeldung.algorithms.linkedlist;
 
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.runners.Parameterized.Parameters;
+
 public class CycleDetectionTestBase {
 
+    @Parameters
+    public static Collection<Object[]> getLists() {
+        return Arrays.asList(new Object[][] { 
+            { createList(), false }, 
+            { createListWithLoop(), true },
+            { createListWithFullCycle(), true }, 
+            { createListWithSingleNodeInCycle(), true } 
+        });
+    }
+
     public static Node<Integer> createList() {
         Node<Integer> root = Node.createNewNode(10, null);
 
@@ -13,6 +28,26 @@ public class CycleDetectionTestBase {
         return root;
     }
 
+    public static Node<Integer> createListWithLoop() {
+        Node<Integer> node = createList();
+        createLoop(node);
+        return node;
+    }
+
+    public static Node<Integer> createListWithFullCycle() {
+        Node<Integer> head = createList();
+        Node<Integer> tail = Node.getTail(head);
+        tail.next = head;
+        return head;
+    }
+
+    public static Node<Integer> createListWithSingleNodeInCycle() {
+        Node<Integer> head = createList();
+        Node<Integer> tail = Node.getTail(head);
+        tail.next = tail;
+        return head;
+    }
+
     public static void createLoop(Node<Integer> root) {
         Node<Integer> tail = Node.getTail(root);
 

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

@@ -2,20 +2,23 @@ package com.baeldung.algorithms.linkedlist;
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
+@RunWith(value = Parameterized.class)
 public class CycleRemovalBruteForceTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
 
-    @Test
-    public void givenNormalList_dontDetectLoop() {
-        Node<Integer> root = createList();
-        Assert.assertFalse(CycleRemovalBruteForce.detectAndRemoveCycle(root));
+    public CycleRemovalBruteForceTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
     }
 
     @Test
-    public void givenCyclicList_detectAndRemoveLoop() {
-        Node<Integer> root = createList();
-        createLoop(root);
-        Assert.assertTrue(CycleRemovalBruteForce.detectAndRemoveCycle(root));
-        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
+        Assert.assertEquals(cycleExists, CycleRemovalBruteForce.detectAndRemoveCycle(head));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
     }
 }

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

@@ -2,20 +2,23 @@ package com.baeldung.algorithms.linkedlist;
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
+@RunWith(value = Parameterized.class)
 public class CycleRemovalByCountingLoopNodesTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
 
-    @Test
-    public void givenNormalList_dontDetectLoop() {
-        Node<Integer> root = createList();
-        Assert.assertFalse(CycleRemovalByCountingLoopNodes.detectAndRemoveCycle(root));
+    public CycleRemovalByCountingLoopNodesTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
     }
 
     @Test
-    public void givenCyclicList_detectAndRemoveLoop() {
-        Node<Integer> root = createList();
-        createLoop(root);
-        Assert.assertTrue(CycleRemovalByCountingLoopNodes.detectAndRemoveCycle(root));
-        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
+        Assert.assertEquals(cycleExists, CycleRemovalByCountingLoopNodes.detectAndRemoveCycle(head));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
     }
 }

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

@@ -2,20 +2,23 @@ package com.baeldung.algorithms.linkedlist;
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 
+@RunWith(value = Parameterized.class)
 public class CycleRemovalWithoutCountingLoopNodesTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
 
-    @Test
-    public void givenNormalList_dontDetectLoop() {
-        Node<Integer> root = createList();
-        Assert.assertFalse(CycleRemovalWithoutCountingLoopNodes.detectAndRemoveCycle(root));
+    public CycleRemovalWithoutCountingLoopNodesTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
     }
 
     @Test
-    public void givenCyclicList_detectAndRemoveLoop() {
-        Node<Integer> root = createList();
-        createLoop(root);
-        Assert.assertTrue(CycleRemovalWithoutCountingLoopNodes.detectAndRemoveCycle(root));
-        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(root));
+    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
+        Assert.assertEquals(cycleExists, CycleRemovalWithoutCountingLoopNodes.detectAndRemoveCycle(head));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
     }
 }

apache-shiro/README.md

@@ -0,0 +1,2 @@
+### Relevant articles
+- [Introduction to Apache Shiro](http://www.baeldung.com/apache-shiro)

bootique/README.md

@@ -0,0 +1,2 @@
+### Relevant Articles:
+- [Introduction to Bootique](http://www.baeldung.com/bootique)

core-java-8/src/test/java/com/baeldung/stream/SupplierStreamTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.stream;
+
+import static org.junit.Assert.fail;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import org.junit.Test;
+
+public class SupplierStreamTest {
+
+    @Test(expected = IllegalStateException.class)
+    public void givenStream_whenStreamUsedTwice_thenThrowException() {
+        Stream<String> stringStream = Stream.of("A", "B", "C", "D");
+        Optional<String> result1 = stringStream.findAny();
+        System.out.println(result1.get());
+        Optional<String> result2 = stringStream.findFirst();
+        System.out.println(result2.get());
+    }
+
+    @Test
+    public void givenStream_whenUsingSupplier_thenNoExceptionIsThrown() {
+        try {
+            Supplier<Stream<String>> streamSupplier = () -> Stream.of("A", "B", "C", "D");
+            Optional<String> result1 = streamSupplier.get().findAny();
+            System.out.println(result1.get());
+            Optional<String> result2 = streamSupplier.get().findFirst();
+            System.out.println(result2.get());
+        } catch (IllegalStateException e) {
+            fail();
+        }
+    }
+
+}

core-java-9/README.md

@@ -16,3 +16,4 @@
 - [Java 9 Optional API Additions](http://www.baeldung.com/java-9-optional)
 - [Java 9 Reactive Streams](http://www.baeldung.com/java-9-reactive-streams)
 - [How to Get All Dates Between Two Dates?](http://www.baeldung.com/java-between-dates)
+- [Java 9 java.util.Objects Additions](http://www.baeldung.com/java-9-objects-new)

core-java-9/src/main/java/com/baeldung/java9/compactstring/CompactStringDemo.java

@@ -0,0 +1,24 @@
+package com.baeldung.java9.compactstring;
+
+import java.util.List;
+import static java.util.stream.Collectors.toList;
+import java.util.stream.IntStream;
+
+public class CompactStringDemo {
+
+    public static void main(String[] args) {
+        long startTime = System.currentTimeMillis();
+        List strings = IntStream.rangeClosed(1, 10_000_000)
+          .mapToObj(Integer::toString).collect(toList());
+        long totalTime = System.currentTimeMillis() - startTime;
+        System.out.println("Generated " + strings.size() + " strings in " 
+          + totalTime + " ms.");
+
+        startTime = System.currentTimeMillis();
+        String appended = (String) strings.stream().limit(100_000)
+          .reduce("", (left, right) -> left.toString() + right.toString());
+        totalTime = System.currentTimeMillis() - startTime;
+        System.out.println("Created string of length " + appended.length() 
+          + " in " + totalTime + " ms.");
+    }
+}

core-java-concurrency/src/test/java/com/baeldung/concurrent/synchronize/BaeldungSychronizedBlockTest.java

@@ -18,7 +18,7 @@ public class BaeldungSychronizedBlockTest {
 
         IntStream.range(0, 1000)
           .forEach(count -> service.submit(synchronizedBlocks::performSynchronisedTask));
-        service.awaitTermination(100, TimeUnit.MILLISECONDS);
+        service.awaitTermination(500, TimeUnit.MILLISECONDS);
 
         assertEquals(1000, synchronizedBlocks.getCount());
     }
@@ -29,7 +29,7 @@ public class BaeldungSychronizedBlockTest {
 
         IntStream.range(0, 1000)
           .forEach(count -> service.submit(BaeldungSynchronizedBlocks::performStaticSyncTask));
-        service.awaitTermination(100, TimeUnit.MILLISECONDS);
+        service.awaitTermination(500, TimeUnit.MILLISECONDS);
 
         assertEquals(1000, BaeldungSynchronizedBlocks.getStaticCount());
     }

core-java/README.md

@@ -99,4 +99,10 @@
 - [ClassNotFoundException vs NoClassDefFoundError](http://www.baeldung.com/java-classnotfoundexception-and-noclassdeffounderror)
 - [Guide to UUID in Java](http://www.baeldung.com/java-uuid)
 - [Guide to Escaping Characters in Java RegExps](http://www.baeldung.com/java-regexp-escape-char)
+- [Guide to hashCode() in Java](http://www.baeldung.com/java-hashcode)
+- [Collect a Java Stream to an Immutable Collection](http://www.baeldung.com/java-stream-immutable-collection)
+- [Difference between URL and URI](http://www.baeldung.com/java-url-vs-uri)
+- [Broadcasting and Multicasting in Java](http://www.baeldung.com/java-broadcast-multicast)
+- [Converting a List to String in Java](http://www.baeldung.com/java-list-to-string)
+- [CharSequence vs. String in Java](http://www.baeldung.com/java-char-sequence-string)
 - [Period and Duration in Java](http://www.baeldung.com/java-period-duration)

core-java/pom.xml

@@ -211,6 +211,11 @@
             <artifactId>jmh-generator-annprocess</artifactId>
             <version>1.19</version>
         </dependency>
+		<dependency>
+		    <groupId>org.springframework</groupId>
+		    <artifactId>spring-web</artifactId>
+		    <version>4.3.4.RELEASE</version>
+		</dependency>
     </dependencies>
 
     <build>
@@ -239,6 +244,7 @@
                 <artifactId>maven-surefire-plugin</artifactId>
                 <configuration>
                     <excludes>
+                        <exclude>**/*LiveTest.java</exclude>
                         <exclude>**/*IntegrationTest.java</exclude>
                         <exclude>**/*LongRunningUnitTest.java</exclude>
                         <exclude>**/*ManualTest.java</exclude>
@@ -373,30 +379,7 @@
                 </configuration>
             </plugin>
 
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>exec-maven-plugin</artifactId>
 
-                <executions>
-                    <execution>
-                        <id>run-benchmarks</id>
-                        <phase>integration-test</phase>
-                        <goals>
-                            <goal>exec</goal>
-                        </goals>
-                        <configuration>
-                            <classpathScope>test</classpathScope>
-                            <executable>java</executable>
-                            <arguments>
-                                <argument>-classpath</argument>
-                                <classpath/>
-                                <argument>org.openjdk.jmh.Main</argument>
-                                <argument>.*</argument>
-                            </arguments>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
         </plugins>
 
     </build>
@@ -431,6 +414,31 @@
                             </systemPropertyVariables>
                         </configuration>
                     </plugin>
+                    <plugin>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>exec-maven-plugin</artifactId>
+
+                        <executions>
+                            <execution>
+                                <id>run-benchmarks</id>
+                            <!--    <phase>integration-test</phase>-->
+                                <phase>none</phase>
+                                <goals>
+                                    <goal>exec</goal>
+                                </goals>
+                                <configuration>
+                                    <classpathScope>test</classpathScope>
+                                    <executable>java</executable>
+                                    <arguments>
+                                        <argument>-classpath</argument>
+                                        <classpath/>
+                                        <argument>org.openjdk.jmh.Main</argument>
+                                        <argument>.*</argument>
+                                    </arguments>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
                 </plugins>
             </build>
         </profile>
@@ -461,7 +469,7 @@
         <protonpack.version>1.13</protonpack.version>
         <streamex.version>0.6.5</streamex.version>
         <vavr.version>0.9.0</vavr.version>
-
+        
         <!-- testing -->
         <org.hamcrest.version>1.3</org.hamcrest.version>
         <junit.version>4.12</junit.version>

core-java/src/main/java/com/baeldung/designpatterns/adapter/AdapterPatternDriver.java

@@ -5,16 +5,16 @@ import static com.baeldung.designpatterns.util.LogerUtil.LOG;
 public class AdapterPatternDriver {
     
     public static void main(String args[]) {
-        LuxuryCars bugattiVeyron = new BugattiVeyron();
-        LuxuryCarsAdapter bugattiVeyronAdapter = new LuxuryCarsAdapterImpl(bugattiVeyron);
-        LOG.info("Bugatti Veyron Super Sport's top speed is " + bugattiVeyronAdapter.speedInKMPH() + " Kmph.");
+    	Movable bugattiVeyron = new BugattiVeyron();
+    	MovableAdapter bugattiVeyronAdapter = new MovableAdapterImpl(bugattiVeyron);
+        LOG.info("Bugatti Veyron Super Sport's top speed is " + bugattiVeyronAdapter.getSpeed() + " Kmph.");
 
-        LuxuryCars mcLaren = new McLaren();
-        LuxuryCarsAdapter mcLarenAdapter = new LuxuryCarsAdapterImpl(mcLaren);
-        LOG.info("McLaren F1 top speed is " + mcLarenAdapter.speedInKMPH() + " Kmph.");
+        Movable mcLaren = new McLaren();
+        MovableAdapter mcLarenAdapter = new MovableAdapterImpl(mcLaren);
+        LOG.info("McLaren F1 top speed is " + mcLarenAdapter.getSpeed() + " Kmph.");
 
-        LuxuryCars astonMartin = new AstonMartin();
-        LuxuryCarsAdapter astonMartinAdapter = new LuxuryCarsAdapterImpl(astonMartin);
-        LOG.info("McLaren F1 top speed is " + astonMartinAdapter.speedInKMPH() + " Kmph.");
+        Movable astonMartin = new AstonMartin();
+        MovableAdapter astonMartinAdapter = new MovableAdapterImpl(astonMartin);
+        LOG.info("McLaren F1 top speed is " + astonMartinAdapter.getSpeed() + " Kmph.");
     }
 }

core-java/src/main/java/com/baeldung/designpatterns/adapter/AstonMartin.java

@@ -1,8 +1,8 @@
 package com.baeldung.designpatterns.adapter;
 
-public class AstonMartin implements LuxuryCars {
+public class AstonMartin implements Movable {
     @Override
-    public double speedInMPH() {
+    public double getSpeed() {
         return 220;
     }
 }

core-java/src/main/java/com/baeldung/designpatterns/adapter/BugattiVeyron.java

@@ -1,8 +1,8 @@
 package com.baeldung.designpatterns.adapter;
 
-public class BugattiVeyron implements LuxuryCars {
+public class BugattiVeyron implements Movable {
     @Override
-    public double speedInMPH() {
+    public double getSpeed() {
         return 268;
     }
 }

core-java/src/main/java/com/baeldung/designpatterns/adapter/LuxuryCars.java

@@ -1,5 +0,0 @@
-package com.baeldung.designpatterns.adapter;
-
-public interface LuxuryCars {
-    public double speedInMPH();
-}

core-java/src/main/java/com/baeldung/designpatterns/adapter/LuxuryCarsAdapter.java

@@ -1,5 +0,0 @@
-package com.baeldung.designpatterns.adapter;
-
-public interface LuxuryCarsAdapter {
-    public double speedInKMPH();
-}

core-java/src/main/java/com/baeldung/designpatterns/adapter/McLaren.java

@@ -1,8 +1,8 @@
 package com.baeldung.designpatterns.adapter;
 
-public class McLaren implements LuxuryCars {
+public class McLaren implements Movable {
     @Override
-    public double speedInMPH() {
+    public double getSpeed() {
         return 241;
     }
 }

core-java/src/main/java/com/baeldung/designpatterns/adapter/Movable.java

@@ -0,0 +1,6 @@
+package com.baeldung.designpatterns.adapter;
+
+public interface Movable {
+    // returns speed in MPH 
+    double getSpeed();
+}