Merge branch 'master' into master

2018-01-11 08:31:58 +00:00
parent 9ff8a53c7d 07750c2266
commit 6d6cc2d50e
280 changed files with 7009 additions and 1260 deletions
@@ -3,7 +3,8 @@ language: java
 before_install: 
  - echo "MAVEN_OPTS='-Xmx2048M -Xss128M -XX:+CMSClassUnloadingEnabled -XX:+UseG1GC -XX:-UseGCOverheadLimit'" > ~/.mavenrc

-install: travis_wait 60 mvn -q test -fae
+install: skip
+script: travis_wait 60 mvn -q test -fae

 sudo: required

@@ -15,3 +15,4 @@
 - [Introduction to JGraphT](http://www.baeldung.com/jgrapht)
 - [Introduction to Minimax Algorithm](http://www.baeldung.com/java-minimax-algorithm)
 - [How to Calculate Levenshtein Distance in Java?](http://www.baeldung.com/java-levenshtein-distance)
+- [How to Find the Kth Largest Element in Java](http://www.baeldung.com/java-kth-largest-element)
@@ -39,6 +39,12 @@
            <artifactId>jgrapht-core</artifactId>
            <version>1.0.1</version>
        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.9.0</version>
+            <scope>test</scope>
+        </dependency>
    </dependencies>

    <build>
@@ -0,0 +1,111 @@
+package com.baeldung.algorithms.kthlargest;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.stream.IntStream;
+
+public class FindKthLargest {
+
+    public int findKthLargestBySorting(Integer[] arr, int k) {
+        Arrays.sort(arr);
+        int targetIndex = arr.length - k;
+        return arr[targetIndex];
+    }
+
+    public int findKthLargestBySortingDesc(Integer[] arr, int k) {
+        Arrays.sort(arr, Collections.reverseOrder());
+        return arr[k - 1];
+    }
+
+    public int findKthElementByQuickSelect(Integer[] arr, int left, int right, int k) {
+        if (k >= 0 && k <= right - left + 1) {
+            int pos = partition(arr, left, right);
+            if (pos - left == k) {
+                return arr[pos];
+            }
+            if (pos - left > k) {
+                return findKthElementByQuickSelect(arr, left, pos - 1, k);
+            }
+            return findKthElementByQuickSelect(arr, pos + 1, right, k - pos + left - 1);
+        }
+        return 0;
+    }
+
+    public int findKthElementByQuickSelectWithIterativePartition(Integer[] arr, int left, int right, int k) {
+        if (k >= 0 && k <= right - left + 1) {
+            int pos = partitionIterative(arr, left, right);
+            if (pos - left == k) {
+                return arr[pos];
+            }
+            if (pos - left > k) {
+                return findKthElementByQuickSelectWithIterativePartition(arr, left, pos - 1, k);
+            }
+            return findKthElementByQuickSelectWithIterativePartition(arr, pos + 1, right, k - pos + left - 1);
+        }
+        return 0;
+    }
+
+    private int partition(Integer[] arr, int left, int right) {
+        int pivot = arr[right];
+        Integer[] leftArr;
+        Integer[] rightArr;
+
+        leftArr = IntStream.range(left, right)
+            .filter(i -> arr[i] < pivot)
+            .map(i -> arr[i])
+            .boxed()
+            .toArray(Integer[]::new);
+
+        rightArr = IntStream.range(left, right)
+            .filter(i -> arr[i] > pivot)
+            .map(i -> arr[i])
+            .boxed()
+            .toArray(Integer[]::new);
+
+        int leftArraySize = leftArr.length;
+        System.arraycopy(leftArr, 0, arr, left, leftArraySize);
+        arr[leftArraySize + left] = pivot;
+        System.arraycopy(rightArr, 0, arr, left + leftArraySize + 1, rightArr.length);
+
+        return left + leftArraySize;
+    }
+
+    private int partitionIterative(Integer[] arr, int left, int right) {
+        int pivot = arr[right], i = left;
+        for (int j = left; j <= right - 1; j++) {
+            if (arr[j] <= pivot) {
+                swap(arr, i, j);
+                i++;
+            }
+        }
+        swap(arr, i, right);
+        return i;
+    }
+
+    public int findKthElementByRandomizedQuickSelect(Integer[] arr, int left, int right, int k) {
+        if (k >= 0 && k <= right - left + 1) {
+            int pos = randomPartition(arr, left, right);
+            if (pos - left == k) {
+                return arr[pos];
+            }
+            if (pos - left > k) {
+                return findKthElementByRandomizedQuickSelect(arr, left, pos - 1, k);
+            }
+            return findKthElementByRandomizedQuickSelect(arr, pos + 1, right, k - pos + left - 1);
+        }
+        return 0;
+    }
+
+    private int randomPartition(Integer arr[], int left, int right) {
+        int n = right - left + 1;
+        int pivot = (int) (Math.random()) % n;
+        swap(arr, left + pivot, right);
+        return partition(arr, left, right);
+    }
+
+    private void swap(Integer[] arr, int n1, int n2) {
+        int temp = arr[n2];
+        arr[n2] = arr[n1];
+        arr[n1] = temp;
+    }
+}
@@ -0,0 +1,57 @@
+package com.baeldung.algorithms.kthlargest;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class FindKthLargestUnitTest {
+
+    private FindKthLargest findKthLargest;
+    private Integer[] arr = { 3, 7, 1, 2, 8, 10, 4, 5, 6, 9 };
+
+    @Before
+    public void setup() {
+        findKthLargest = new FindKthLargest();
+    }
+
+    @Test
+    public void givenIntArray_whenFindKthLargestBySorting_thenGetResult() {
+        int k = 3;
+        assertThat(findKthLargest.findKthLargestBySorting(arr, k)).isEqualTo(8);
+    }
+
+    @Test
+    public void givenIntArray_whenFindKthLargestBySortingDesc_thenGetResult() {
+        int k = 3;
+        assertThat(findKthLargest.findKthLargestBySortingDesc(arr, k)).isEqualTo(8);
+    }
+
+    @Test
+    public void givenIntArray_whenFindKthLargestByQuickSelect_thenGetResult() {
+        int k = 3;
+        int kthLargest = arr.length - k;
+        assertThat(findKthLargest.findKthElementByQuickSelect(arr, 0, arr.length - 1, kthLargest)).isEqualTo(8);
+    }
+
+    @Test
+    public void givenIntArray_whenFindKthElementByQuickSelectIterative_thenGetResult() {
+        int k = 3;
+        int kthLargest = arr.length - k;
+        assertThat(findKthLargest.findKthElementByQuickSelectWithIterativePartition(arr, 0, arr.length - 1, kthLargest)).isEqualTo(8);
+    }
+
+    @Test
+    public void givenIntArray_whenFindKthSmallestByQuickSelect_thenGetResult() {
+        int k = 3;
+        assertThat(findKthLargest.findKthElementByQuickSelect(arr, 0, arr.length - 1, k - 1)).isEqualTo(3);
+    }
+
+    @Test
+    public void givenIntArray_whenFindKthLargestByRandomizedQuickSelect_thenGetResult() {
+        int k = 3;
+        int kthLargest = arr.length - k;
+        assertThat(findKthLargest.findKthElementByRandomizedQuickSelect(arr, 0, arr.length - 1, kthLargest)).isEqualTo(8);
+    }
+
+}
@@ -1,4 +1,4 @@
-package com.baeldung.streamApi;
+package com.baeldung.stream;

 import java.util.List;
 import java.util.stream.Stream;
@@ -16,7 +16,7 @@ public class StreamApi {
    }
    
    public static String getLastElementUsingSkip(List<String> valueList) {
-        long count = valueList.stream().count();
+        long count = (long) valueList.size();
        Stream<String> stream = valueList.stream();
        return stream.skip(count - 1).findFirst().orElse(null);
    }
@@ -1,6 +1,6 @@
 package com.baeldung.java8;

-import com.baeldung.streamApi.Product;
+import com.baeldung.stream.Product;
 import org.junit.Before;
 import org.junit.Test;
 import org.slf4j.Logger;
@@ -6,6 +6,7 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
+import java.util.stream.Stream;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -65,7 +66,9 @@ public class PrimitiveStreamsUnitTest {
    @Test
    public void givenAnArrayWhenSumIsCalledThenTheCorrectSumIsReturned() {

-        int sum = Arrays.asList(33,45).stream().mapToInt(a -> a).sum();
+        int sum = Stream.of(33,45)
+          .mapToInt(i -> i)
+          .sum();

        assertEquals(78, sum);
    }
@@ -0,0 +1,101 @@
+package com.baeldung.stringjoiner;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.StringJoiner;
+import java.util.stream.Collectors;
+
+import org.junit.Test;
+
+public class StringJoinerUnitTest {
+    private final String DELIMITER_COMMA = ",";
+    private final String DELIMITER_HYPHEN = "-";
+    private final String PREFIX = "[";
+    private final String SUFFIX = "]";
+    private final String EMPTY_JOINER = "empty";
+
+    @Test
+    public void whenJoinerWithoutPrefixSuffixWithoutEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedJoiner = new StringJoiner(DELIMITER_COMMA);
+        assertEquals(0, commaSeparatedJoiner.toString().length());
+    }
+
+    @Test
+    public void whenJoinerWithPrefixSuffixWithoutEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedPrefixSuffixJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        assertEquals(commaSeparatedPrefixSuffixJoiner.toString(), PREFIX + SUFFIX);
+    }
+
+    @Test
+    public void whenJoinerWithoutPrefixSuffixWithEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedJoiner = new StringJoiner(DELIMITER_COMMA);
+        commaSeparatedJoiner.setEmptyValue(EMPTY_JOINER);
+
+        assertEquals(commaSeparatedJoiner.toString(), EMPTY_JOINER);
+    }
+
+    @Test
+    public void whenJoinerWithPrefixSuffixWithEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedPrefixSuffixJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        commaSeparatedPrefixSuffixJoiner.setEmptyValue(EMPTY_JOINER);
+
+        assertEquals(commaSeparatedPrefixSuffixJoiner.toString(), EMPTY_JOINER);
+    }
+
+    @Test
+    public void whenAddElements_thenJoinElements() {
+        StringJoiner rgbJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        rgbJoiner.add("Red")
+          .add("Green")
+          .add("Blue");
+
+        assertEquals(rgbJoiner.toString(), "[Red,Green,Blue]");
+    }
+
+    @Test
+    public void whenAddListElements_thenJoinListElements() {
+        List<String> rgbList = new ArrayList<String>();
+        rgbList.add("Red");
+        rgbList.add("Green");
+        rgbList.add("Blue");
+
+        StringJoiner rgbJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+
+        for (String color : rgbList) {
+            rgbJoiner.add(color);
+        }
+
+        assertEquals(rgbJoiner.toString(), "[Red,Green,Blue]");
+    }
+
+    @Test
+    public void whenMergeJoiners_thenReturnMerged() {
+        StringJoiner rgbJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        StringJoiner cmybJoiner = new StringJoiner(DELIMITER_HYPHEN, PREFIX, SUFFIX);
+
+        rgbJoiner.add("Red")
+          .add("Green")
+          .add("Blue");
+        cmybJoiner.add("Cyan")
+          .add("Magenta")
+          .add("Yellow")
+          .add("Black");
+
+        rgbJoiner.merge(cmybJoiner);
+
+        assertEquals(rgbJoiner.toString(), "[Red,Green,Blue,Cyan-Magenta-Yellow-Black]");
+    }
+
+    @Test
+    public void whenUsedWithinCollectors_thenJoin() {
+        List<String> rgbList = Arrays.asList("Red", "Green", "Blue");
+        String commaSeparatedRGB = rgbList.stream()
+          .map(color -> color.toString())
+          .collect(Collectors.joining(","));
+
+        assertEquals(commaSeparatedRGB, "Red,Green,Blue");
+    }
+}
@@ -2,10 +2,10 @@
    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-java9</artifactId>
+    <artifactId>core-java-9</artifactId>
    <version>0.2-SNAPSHOT</version>

-    <name>core-java9</name>
+    <name>core-java-9</name>

    <pluginRepositories>
        <pluginRepository>
@@ -1,20 +1,21 @@
 package com.baeldung.concurrent.stopping;

-import com.jayway.awaitility.Awaitility;
-import org.junit.Test;
-
-import java.util.concurrent.TimeUnit;
-
 import static com.jayway.awaitility.Awaitility.await;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;

+import java.util.concurrent.TimeUnit;
+
+import org.junit.Test;
+
+import com.jayway.awaitility.Awaitility;
+
 public class StopThreadTest {

    @Test
    public void whenStoppedThreadIsStopped() throws InterruptedException {

-        int interval = 100;
+        int interval = 5;

        ControlSubThread controlSubThread = new ControlSubThread(interval);
        controlSubThread.start();
@@ -33,13 +34,13 @@ public class StopThreadTest {
    @Test
    public void whenInterruptedThreadIsStopped() throws InterruptedException {

-        int interval = 5000;
+        int interval = 50;

        ControlSubThread controlSubThread = new ControlSubThread(interval);
        controlSubThread.start();

        // Give things a chance to get set up
-        Thread.sleep(100);
+        Thread.sleep(interval);
        assertTrue(controlSubThread.isRunning());
        assertFalse(controlSubThread.isStopped());

@@ -48,6 +49,7 @@ public class StopThreadTest {

        // Wait less than the time we would normally sleep, and make sure we exited.
        Awaitility.await()
+            .pollDelay(2, TimeUnit.MILLISECONDS)
          .atMost(interval/ 10, TimeUnit.MILLISECONDS)
          .until(controlSubThread::isStopped);
    }
@@ -131,4 +131,6 @@
 - [How to Invert an Array in Java](http://www.baeldung.com/java-invert-array)
 - [Guide to the Cipher Class](http://www.baeldung.com/java-cipher-class)
 - [A Guide to Java Initialization](http://www.baeldung.com/java-initialization)
-
+- [Implementing a Binary Tree in Java](http://www.baeldung.com/java-binary-tree)
+- [A Guide to ThreadLocalRandom in Java](http://www.baeldung.com/java-thread-local-random)
+- [RegEx for matching Date Pattern in Java](http://www.baeldung.com/java-date-regular-expressions)
@@ -389,6 +389,16 @@
                    </arguments>
                </configuration>
            </plugin>
+            
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+                <version>3.0.0-M1</version>
+                <configuration>
+                    <source>1.8</source>
+	                <target>1.8</target>
+                </configuration>
+            </plugin>


        </plugins>
@@ -0,0 +1,39 @@
+package com.baeldung.iteratorguide;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class IteratorGuide {
+    
+    public static void main(String[] args) {
+        List<String> items = new ArrayList<>();
+        items.add("ONE");
+        items.add("TWO");
+        items.add("THREE");
+        Iterator<String> iter = items.iterator();
+        while (iter.hasNext()) {
+                String next = iter.next();
+                System.out.println(next);
+                iter.remove();
+        }
+        ListIterator<String> listIterator = items.listIterator();
+        while(listIterator.hasNext()) {
+            String nextWithIndex = items.get(listIterator.nextIndex());
+            String next = listIterator.next();
+            if( "ONE".equals(next)) {
+                listIterator.set("SWAPPED");
+            }
+        }
+        listIterator.add("FOUR");
+        while(listIterator.hasPrevious()) {
+            String previousWithIndex = items.get(listIterator.previousIndex());
+            String previous = listIterator.previous();
+            System.out.println(previous);
+        }
+        listIterator.forEachRemaining(e -> {
+            System.out.println(e);
+        });
+    }
+}
@@ -0,0 +1,22 @@
+package com.baeldung.javadoc;
+
+public class Person {
+	/**
+	 * This is a first name
+	 */
+	private String firstName;
+	private String lastName;
+	
+	public String getFirstName() {
+		return firstName;
+	}
+	public void setFirstName(String firstName) {
+		this.firstName = firstName;
+	}
+	public String getLastName() {
+		return lastName;
+	}
+	public void setLastName(String lastName) {
+		this.lastName = lastName;
+	}
+}
@@ -0,0 +1,64 @@
+package com.baeldung.javadoc;
+
+/**
+ * Hero is the main entity we will be using to . . .
+ * @author Captain America
+ * 
+ */
+public class SuperHero extends Person {
+
+    /**
+     * The public name of a hero that is common knowledge
+     */
+    private String heroName;
+    private String uniquePower;
+    private int health;
+    private int defense;
+	
+    /**
+     * <p>This is a simple description of the method. . .
+     * <a href="http://www.supermanisthegreatest.com">Superman!</a>
+     * </p>
+     * @param incomingDamage the amount of incoming damage
+     * @return the amount of health hero has after attack
+     * @see <a href="http://www.link_to_jira/HERO-402">HERO-402</a>
+     * @since 1.0
+     */
+    public int successfullyAttacked(int incomingDamage, String damageType) {
+    	// do things
+        return 0;
+    }
+
+	public String getHeroName() {
+		return heroName;
+	}
+
+	public void setHeroName(String heroName) {
+		this.heroName = heroName;
+	}
+
+	public String getUniquePower() {
+		return uniquePower;
+	}
+
+	public void setUniquePower(String uniquePower) {
+		this.uniquePower = uniquePower;
+	}
+
+	public int getHealth() {
+		return health;
+	}
+
+	public void setHealth(int health) {
+		this.health = health;
+	}
+
+	public int getDefense() {
+		return defense;
+	}
+
+	public void setDefense(int defense) {
+		this.defense = defense;
+	}
+	
+}
@@ -0,0 +1,7 @@
+package com.baeldung.regexp.datepattern;
+
+public interface DateMatcher {
+
+    boolean matches(String date);
+
+}
@@ -0,0 +1,14 @@
+package com.baeldung.regexp.datepattern;
+
+import java.util.regex.Pattern;
+
+class FormattedDateMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^\\d{4}-\\d{2}-\\d{2}$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}
@@ -0,0 +1,14 @@
+package com.baeldung.regexp.datepattern;
+
+import java.util.regex.Pattern;
+
+class RangedDateMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^((19|2[0-9])[0-9]{2})-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}
@@ -0,0 +1,16 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class February29thMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^((2000|2400|2800|(19|2[0-9](0[48]|[2468][048]|[13579][26])))-02-29)$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}
@@ -0,0 +1,16 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class FebruaryGeneralMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^(((19|2[0-9])[0-9]{2})-02-(0[1-9]|1[0-9]|2[0-8]))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}
@@ -0,0 +1,19 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+class GregorianDateMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^((2000|2400|2800|(19|2[0-9](0[48]|[2468][048]|[13579][26])))-02-29)$" 
+            + "|^(((19|2[0-9])[0-9]{2})-02-(0[1-9]|1[0-9]|2[0-8]))$"
+            + "|^(((19|2[0-9])[0-9]{2})-(0[13578]|10|12)-(0[1-9]|[12][0-9]|3[01]))$" 
+            + "|^(((19|2[0-9])[0-9]{2})-(0[469]|11)-(0[1-9]|[12][0-9]|30))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+}
@@ -0,0 +1,17 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class MonthsOf30DaysMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^(((19|2[0-9])[0-9]{2})-(0[469]|11)-(0[1-9]|[12][0-9]|30))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+
+}
@@ -0,0 +1,17 @@
+package com.baeldung.regexp.datepattern.gregorian;
+
+import com.baeldung.regexp.datepattern.DateMatcher;
+
+import java.util.regex.Pattern;
+
+public class MonthsOf31DaysMatcher implements DateMatcher {
+
+    private static final Pattern DATE_PATTERN = Pattern.compile(
+            "^(((19|2[0-9])[0-9]{2})-(0[13578]|10|12)-(0[1-9]|[12][0-9]|3[01]))$");
+
+    @Override
+    public boolean matches(String date) {
+        return DATE_PATTERN.matcher(date).matches();
+    }
+
+}
@@ -16,7 +16,7 @@ public class EchoMultiServer {
        try {
            serverSocket = new ServerSocket(port);
            while (true)
-                new EchoClientHandler(serverSocket.accept()).run();
+                new EchoClientHandler(serverSocket.accept()).start();

        } catch (IOException e) {
            e.printStackTrace();
@@ -0,0 +1,33 @@
+package com.baeldung.staticclass;
+
+public class Pizza {
+
+    private static String cookedCount;
+    private boolean isThinCrust;
+
+    // Accessible globally
+    public static class PizzaSalesCounter {
+
+        private static String orderedCount;
+        public static String deliveredCount;
+
+        PizzaSalesCounter() {
+            System.out.println("Static field of enclosing class is "
+              + Pizza.cookedCount);
+            System.out.println("Non-static field of enclosing class is "
+              + new Pizza().isThinCrust);
+        }
+    }
+
+    Pizza() {
+        System.out.println("Non private static field of static class is "
+          + PizzaSalesCounter.deliveredCount);
+        System.out.println("Private static field of static class is "
+          + PizzaSalesCounter.orderedCount);
+    }
+
+    public static void main(String[] a) {
+        // Create instance of the static class without an instance of enclosing class
+        new Pizza.PizzaSalesCounter();
+    }
+}
@@ -0,0 +1,22 @@
+package com.baeldung.threadlocalrandom;
+
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+public class ThreadLocalRandomBenchMarkRunner {
+
+    public static void main(String[] args) throws Exception {
+
+        Options options = new OptionsBuilder().include(ThreadLocalRandomBenchMarker.class.getSimpleName())
+            .threads(1)
+            .forks(1)
+            .shouldFailOnError(true)
+            .shouldDoGC(true)
+            .jvmArgs("-server")
+            .build();
+
+        new Runner(options).run();
+
+    }
+}
@@ -0,0 +1,64 @@
+package com.baeldung.threadlocalrandom;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.TimeUnit;
+
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 1)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+public class ThreadLocalRandomBenchMarker {
+
+    List<Callable<Integer>> randomCallables = new ArrayList<>();
+    List<Callable<Integer>> threadLocalRandomCallables = new ArrayList<>();
+
+    @Setup(Level.Iteration)
+    public void init() {
+        Random random = new Random();
+        randomCallables = new ArrayList<>();
+        threadLocalRandomCallables = new ArrayList<>();
+        for (int i = 0; i < 1000; i++) {
+            randomCallables.add(() -> {
+                return random.nextInt();
+            });
+        }
+
+        for (int i = 0; i < 1000; i++) {
+            threadLocalRandomCallables.add(() -> {
+                return ThreadLocalRandom.current()
+                    .nextInt();
+            });
+        }
+    }
+
+    @Benchmark
+    public void randomValuesUsingRandom() throws InterruptedException {
+        ExecutorService executor = Executors.newWorkStealingPool();
+        executor.invokeAll(randomCallables);
+        executor.shutdown();
+    }
+
+    @Benchmark
+    public void randomValuesUsingThreadLocalRandom() throws InterruptedException {
+        ExecutorService executor = Executors.newWorkStealingPool();
+        executor.invokeAll(threadLocalRandomCallables);
+        executor.shutdown();
+    }
+
+}
@@ -0,0 +1,24 @@
+package com.baeldung.regexp.datepattern;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class FormattedDateMatcherUnitTest {
+
+    private DateMatcher matcher = new FormattedDateMatcher();
+
+    @Test
+    public void whenUsingFormattedDateMatcher_thenFormatConstraintsSatisfied() {
+        Assert.assertTrue(matcher.matches("2017-12-31"));
+        Assert.assertTrue(matcher.matches("2018-01-01"));
+        Assert.assertTrue(matcher.matches("0000-00-00"));
+        Assert.assertTrue(matcher.matches("1029-99-72"));
+
+        Assert.assertFalse(matcher.matches("2018-01"));
+        Assert.assertFalse(matcher.matches("2018-01-01-01"));
+        Assert.assertFalse(matcher.matches("2018-01-XX"));
+        Assert.assertFalse(matcher.matches(" 2018-01-01"));
+        Assert.assertFalse(matcher.matches("2018-01-01 "));
+        Assert.assertFalse(matcher.matches("2018/01/01"));
+    }
+}
--- a/Show More
+++ b/Show More