Merge pull request eugenp#2 from eugenp/master

Getting latest changes from main repository

Author: chandra1123

.gitignore

@@ -42,3 +42,9 @@ spring-check-if-a-property-is-null/.mvn/wrapper/maven-wrapper.properties
 *.springBeans
 
 20171220-JMeter.csv
+
+.factorypath
+dependency-reduced-pom.xml
+*.so
+*.dylib
+*.dll

README.md

@@ -39,3 +39,4 @@ This tutorials project is being built **[>> HERE](https://rest-security.ci.cloud
 
 - [Apache Maven Standard Directory Layout](http://www.baeldung.com/maven-directory-structure)
 - [Apache Maven Tutorial](http://www.baeldung.com/maven)
+- [Designing a User Friendly Java Library](http://www.baeldung.com/design-a-user-friendly-java-library)

algorithms/src/main/java/com/baeldung/algorithms/mcts/montecarlo/MonteCarloTreeSearch.java

@@ -10,7 +10,7 @@ public class MonteCarloTreeSearch {
 
     private static final int WIN_SCORE = 10;
     private int level;
-    private int oponent;
+    private int opponent;
 
     public MonteCarloTreeSearch() {
         this.level = 3;
@@ -32,11 +32,11 @@ public Board findNextMove(Board board, int playerNo) {
         long start = System.currentTimeMillis();
         long end = start + 60 * getMillisForCurrentLevel();
 
-        oponent = 3 - playerNo;
+        opponent = 3 - playerNo;
         Tree tree = new Tree();
         Node rootNode = tree.getRoot();
         rootNode.getState().setBoard(board);
-        rootNode.getState().setPlayerNo(oponent);
+        rootNode.getState().setPlayerNo(opponent);
 
         while (System.currentTimeMillis() < end) {
             // Phase 1 - Selection
@@ -93,7 +93,7 @@ private int simulateRandomPlayout(Node node) {
         State tempState = tempNode.getState();
         int boardStatus = tempState.getBoard().checkStatus();
 
-        if (boardStatus == oponent) {
+        if (boardStatus == opponent) {
             tempNode.getParent().getState().setWinScore(Integer.MIN_VALUE);
             return boardStatus;
         }

…dung/linkedlist/MiddleElementLookup.java …leelementlookup/MiddleElementLookup.javacore-java/src/main/java/com/baeldung/linkedlist/MiddleElementLookup.java renamed to algorithms/src/main/java/com/baeldung/algorithms/middleelementlookup/MiddleElementLookup.java core-java/src/main/java/com/baeldung/linkedlist/MiddleElementLookup.java renamed to algorithms/src/main/java/com/baeldung/algorithms/middleelementlookup/MiddleElementLookup.java

@@ -1,22 +1,21 @@
-package com.baeldung.linkedlist;
+package com.baeldung.algorithms.middleelementlookup;
 
 import java.util.LinkedList;
-
-import com.baeldung.linkedlist.Node;
+import java.util.Optional;
 
 public class MiddleElementLookup {
 
-    public static String findMiddleElementLinkedList(LinkedList<String> linkedList) {
+    public static Optional<String> findMiddleElementLinkedList(LinkedList<String> linkedList) {
         if (linkedList == null || linkedList.isEmpty()) {
-            return null;
+            return Optional.empty();
         }
 
-        return linkedList.get((linkedList.size() - 1) / 2);
+        return Optional.ofNullable(linkedList.get((linkedList.size() - 1) / 2));
     }
 
-    public static String findMiddleElementFromHead(Node head) {
+    public static Optional<String> findMiddleElementFromHead(Node head) {
         if (head == null) {
-            return null;
+            return Optional.empty();
         }
 
         // calculate the size of the list
@@ -33,17 +32,17 @@ public static String findMiddleElementFromHead(Node head) {
             current = current.next();
         }
 
-        return current.data();
+        return Optional.ofNullable(current.data());
     }
 
-    public static String findMiddleElementFromHead1PassRecursively(Node head) {
+    public static Optional<String> findMiddleElementFromHead1PassRecursively(Node head) {
         if (head == null) {
-            return null;
+            return Optional.empty();
         }
 
         MiddleAuxRecursion middleAux = new MiddleAuxRecursion();
         findMiddleRecursively(head, middleAux);
-        return middleAux.middle.data();
+        return Optional.ofNullable(middleAux.middle.data());
     }
 
     private static void findMiddleRecursively(Node node, MiddleAuxRecursion middleAux) {
@@ -63,9 +62,9 @@ private static void findMiddleRecursively(Node node, MiddleAuxRecursion middleAu
         middleAux.length--;
     }
 
-    public static String findMiddleElementFromHead1PassIteratively(Node head) {
+    public static Optional<String> findMiddleElementFromHead1PassIteratively(Node head) {
         if (head == null) {
-            return null;
+            return Optional.empty();
         }
 
         Node slowPointer = head;
@@ -78,7 +77,7 @@ public static String findMiddleElementFromHead1PassIteratively(Node head) {
             slowPointer = slowPointer.next();
         }
 
-        return slowPointer.data();
+        return Optional.ofNullable(slowPointer.data());
     }
 
     private static class MiddleAuxRecursion {

…n/java/com/baeldung/linkedlist/Node.java …algorithms/middleelementlookup/Node.javacore-java/src/main/java/com/baeldung/linkedlist/Node.java renamed to algorithms/src/main/java/com/baeldung/algorithms/middleelementlookup/Node.java core-java/src/main/java/com/baeldung/linkedlist/Node.java renamed to algorithms/src/main/java/com/baeldung/algorithms/middleelementlookup/Node.java

@@ -1,4 +1,4 @@
-package com.baeldung.linkedlist;
+package com.baeldung.algorithms.middleelementlookup;
 
 public class Node {
     private Node next;

algorithms/src/main/java/com/baeldung/algorithms/romannumerals/RomanArabicConverter.java

@@ -0,0 +1,52 @@
+package com.baeldung.algorithms.romannumerals;
+
+import java.util.List;
+
+class RomanArabicConverter {
+
+    public static int romanToArabic(String input) {
+        String romanNumeral = input.toUpperCase();
+        int result = 0;
+        
+        List<RomanNumeral> romanNumerals = RomanNumeral.getReverseSortedValues();
+
+        int i = 0;
+
+        while ((romanNumeral.length() > 0) && (i < romanNumerals.size())) {
+            RomanNumeral symbol = romanNumerals.get(i);
+            if (romanNumeral.startsWith(symbol.name())) {
+                result += symbol.getValue();
+                romanNumeral = romanNumeral.substring(symbol.name().length());
+            } else {
+                i++;
+            }
+        }
+        if (romanNumeral.length() > 0) {
+            throw new IllegalArgumentException(input + " cannot be converted to a Roman Numeral");
+        }
+
+        return result;
+    }
+
+    public static String arabicToRoman(int number) {
+        if ((number <= 0) || (number > 4000)) {
+            throw new IllegalArgumentException(number + " is not in range (0,4000]");
+        }
+
+        List<RomanNumeral> romanNumerals = RomanNumeral.getReverseSortedValues();
+
+        int i = 0;
+        StringBuilder sb = new StringBuilder();
+
+        while (number > 0 && i < romanNumerals.size()) {
+            RomanNumeral currentSymbol = romanNumerals.get(i);
+            if (currentSymbol.getValue() <= number) {
+                sb.append(currentSymbol.name());
+                number -= currentSymbol.getValue();
+            } else {
+                i++;
+            }
+        }
+        return sb.toString();
+    }
+}

algorithms/src/main/java/com/baeldung/algorithms/romannumerals/RomanNumeral.java

@@ -0,0 +1,26 @@
+package com.baeldung.algorithms.romannumerals;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+enum RomanNumeral {
+    I(1), IV(4), V(5), IX(9), X(10), XL(40), L(50), XC(90), C(100), CD(400), D(500), CM(900), M(1000);
+
+    private int value;
+
+    RomanNumeral(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+    
+    public static List<RomanNumeral> getReverseSortedValues() {
+        return Arrays.stream(values())
+          .sorted(Comparator.comparing((RomanNumeral e) -> e.value).reversed())
+          .collect(Collectors.toList());
+    }
+}

algorithms/src/test/java/algorithms/MiddleElementLookupUnitTest.java

@@ -0,0 +1,118 @@
+package algorithms;
+
+import com.baeldung.algorithms.middleelementlookup.MiddleElementLookup;
+import com.baeldung.algorithms.middleelementlookup.Node;
+import org.junit.Test;
+
+import java.util.LinkedList;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+public class MiddleElementLookupUnitTest {
+
+    @Test
+    public void whenFindingMiddleLinkedList_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementLinkedList(createLinkedList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementLinkedList(createLinkedList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead1PassRecursively_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead1PassIteratively_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenListEmptyOrNull_thenMiddleNotFound() {
+        // null list
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(null)
+          .isPresent());
+
+        // empty LinkedList
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(new LinkedList<>())
+          .isPresent());
+
+        // LinkedList with nulls
+        LinkedList<String> nullsList = new LinkedList<>();
+        nullsList.add(null);
+        nullsList.add(null);
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(nullsList)
+          .isPresent());
+
+        // nodes with null values
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead(new Node(null))
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(new Node(null))
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(new Node(null))
+          .isPresent());
+    }
+
+    private static LinkedList<String> createLinkedList(int n) {
+        LinkedList<String> list = new LinkedList<>();
+
+        for (int i = 1; i <= n; i++) {
+            list.add(String.valueOf(i));
+        }
+
+        return list;
+    }
+
+    private static Node createNodesList(int n) {
+        Node head = new Node("1");
+        Node current = head;
+
+        for (int i = 2; i <= n; i++) {
+            Node newNode = new Node(String.valueOf(i));
+            current.setNext(newNode);
+            current = newNode;
+        }
+
+        return head;
+    }
+
+}