Merge remote-tracking branch 'eugenp/master'

README.md

@@ -2,7 +2,7 @@
 The "REST with Spring" Classes
 ==============================
 
-After 5 months of work, here's the Master Class of REST With Spring: <br/>
+Here's the Master Class of REST With Spring (price changes permanently next Friday): <br/>
 **[>> THE REST WITH SPRING MASTER CLASS](http://www.baeldung.com/rest-with-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=rws#master-class)**
 
 And here's the Master Class of Learn Spring Security: <br/>

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

@@ -87,7 +87,7 @@ public class State {
     void randomPlay() {
         List<Position> availablePositions = this.board.getEmptyPositions();
         int totalPossibilities = availablePositions.size();
-        int selectRandom = (int) (Math.random() * ((totalPossibilities - 1) + 1));
+        int selectRandom = (int) (Math.random() * totalPossibilities);
         this.board.performMove(this.playerNo, availablePositions.get(selectRandom));
     }
 

algorithms/src/main/java/com/baeldung/algorithms/mcts/tree/Node.java

@@ -65,7 +65,7 @@ public class Node {
 
     public Node getRandomChildNode() {
         int noOfPossibleMoves = this.childArray.size();
-        int selectRandom = (int) (Math.random() * ((noOfPossibleMoves - 1) + 1));
+        int selectRandom = (int) (Math.random() * noOfPossibleMoves);
         return this.childArray.get(selectRandom);
     }
 

algorithms/src/main/java/com/baeldung/algorithms/string/EnglishAlphabetLetters.java

@@ -0,0 +1,35 @@
+package com.baeldung.algorithms.string;
+
+public class EnglishAlphabetLetters {
+
+    public static boolean checkStringForAllTheLetters(String input) {
+        boolean[] visited = new boolean[26];
+
+        int index = 0;
+
+        for (int id = 0; id < input.length(); id++) {
+            if ('a' <= input.charAt(id) && input.charAt(id) <= 'z') {
+                index = input.charAt(id) - 'a';
+            } else if ('A' <= input.charAt(id) && input.charAt(id) <= 'Z') {
+                index = input.charAt(id) - 'A';
+            }
+            visited[index] = true;
+        }
+
+        for (int id = 0; id < 26; id++) {
+            if (!visited[id]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static boolean checkStringForAllLetterUsingStream(String input) {
+        long c = input.toLowerCase().chars().filter(ch -> ch >= 'a' && ch <= 'z').distinct().count();
+        return c == 26;
+    }
+
+    public static void main(String[] args) {
+        checkStringForAllLetterUsingStream("intit");
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/AntColonyOptimizationLongRunningUnitTest.java

@@ -1,4 +1,4 @@
-package algorithms;
+package com.baeldung.algorithms;
 
 import org.junit.Assert;
 import org.junit.Test;

algorithms/src/test/java/com/baeldung/algorithms/BinaryGeneticAlgorithmLongRunningUnitTest.java

@@ -1,4 +1,4 @@
-package algorithms;
+package com.baeldung.algorithms;
 
 import org.junit.Assert;
 import org.junit.Test;

algorithms/src/test/java/com/baeldung/algorithms/DijkstraAlgorithmLongRunningUnitTest.java

@@ -1,4 +1,4 @@
-package algorithms;
+package com.baeldung.algorithms;
 
 import org.junit.Test;
 

algorithms/src/test/java/com/baeldung/algorithms/HillClimbingAlgorithmUnitTest.java

@@ -1,4 +1,4 @@
-package algorithms;
+package com.baeldung.algorithms;
 
 import com.baeldung.algorithms.hillclimbing.HillClimbing;
 import com.baeldung.algorithms.hillclimbing.State;

algorithms/src/test/java/com/baeldung/algorithms/MiddleElementLookupUnitTest.java

@@ -1,4 +1,4 @@
-package algorithms;
+package com.baeldung.algorithms;
 
 import com.baeldung.algorithms.middleelementlookup.MiddleElementLookup;
 import com.baeldung.algorithms.middleelementlookup.Node;

algorithms/src/test/java/com/baeldung/algorithms/RtFiniteStateMachineLongRunningUnitTest.java

@@ -1,4 +1,4 @@
-package algorithms;
+package com.baeldung.algorithms;
 
 import com.baeldung.algorithms.automata.*;
 import org.junit.Test;

algorithms/src/test/java/com/baeldung/algorithms/SimulatedAnnealingLongRunningUnitTest.java

@@ -1,4 +1,4 @@
-package algorithms;
+package com.baeldung.algorithms;
 
 import org.junit.Assert;
 import org.junit.Test;

algorithms/src/test/java/com/baeldung/algorithms/StringSearchAlgorithmsUnitTest.java

@@ -1,4 +1,4 @@
-package algorithms;
+package com.baeldung.algorithms;
 
 
 import org.junit.Assert;

algorithms/src/test/java/com/baeldung/algorithms/binarysearch/BinarySearchUnitTest.java

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

algorithms/src/test/java/com/baeldung/algorithms/mcts/MCTSUnitTest.java

@@ -1,4 +1,4 @@
-package algorithms.mcts;
+package com.baeldung.algorithms.mcts;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;

algorithms/src/test/java/com/baeldung/algorithms/minimax/MinimaxUnitTest.java

@@ -1,4 +1,4 @@
-package algorithms.minimax;
+package com.baeldung.algorithms.minimax;
 
 import org.junit.Before;
 import org.junit.Test;

algorithms/src/test/java/com/baeldung/algorithms/string/EnglishAlphabetLettersUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.string;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class EnglishAlphabetLettersUnitTest {
+
+    @Test
+    void givenString_whenContainsAllCharacter_thenTrue() {
+        String input = "Farmer jack realized that big yellow quilts were expensive";
+        Assertions.assertTrue(EnglishAlphabetLetters.checkStringForAllTheLetters(input));
+    }
+
+    @Test
+    void givenString_whenContainsAllCharacter_thenUsingStreamExpectTrue() {
+        String input = "Farmer jack realized that big yellow quilts were expensive";
+        Assertions.assertTrue(EnglishAlphabetLetters.checkStringForAllLetterUsingStream(input));
+    }
+
+}

core-java-8/README.md

@@ -9,33 +9,18 @@
 - [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)
 - [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)
-- [“Stream has already been operated upon or closed” Exception in Java](http://www.baeldung.com/java-stream-operated-upon-or-closed-exception)
-- [Display All Time Zones With GMT And UTC in Java](http://www.baeldung.com/java-time-zones)
 - [Copy a File with Java](http://www.baeldung.com/java-copy-file)
 - [Static and Default Methods in Interfaces in Java](http://www.baeldung.com/java-static-default-methods)
-- [Iterable to Stream in Java](http://www.baeldung.com/java-iterable-to-stream)
-- [How to Iterate Over a Stream With Indices](http://www.baeldung.com/java-stream-indices)
 - [Efficient Word Frequency Calculator in Java](http://www.baeldung.com/java-word-frequency)
-- [Primitive Type Streams in Java 8](http://www.baeldung.com/java-8-primitive-streams)
 - [Fail-Safe Iterator vs Fail-Fast Iterator](http://www.baeldung.com/java-fail-safe-vs-fail-fast-iterator)
 - [Shuffling Collections In Java](http://www.baeldung.com/java-shuffle-collection)
 - [Introduction to Spliterator in Java](http://www.baeldung.com/java-spliterator)
@@ -44,15 +29,10 @@
 - [Finding Min/Max in an Array with Java](http://www.baeldung.com/java-array-min-max)
 - [Internationalization and Localization in Java 8](http://www.baeldung.com/java-8-localization)
 - [How to Find an Element in a List with Java](http://www.baeldung.com/find-list-element-java)
-- [Measure Elapsed Time in Java](http://www.baeldung.com/java-measure-elapsed-time)
 - [Java Optional – orElse() vs orElseGet()](http://www.baeldung.com/java-optional-or-else-vs-or-else-get)
 - [An Introduction to Java.util.Hashtable Class](http://www.baeldung.com/java-hash-table)
 - [Method Parameter Reflection in Java](http://www.baeldung.com/java-parameter-reflection)
 - [Java 8 Unsigned Arithmetic Support](http://www.baeldung.com/java-unsigned-arithmetic)
-- [How to Get the Start and the End of a Day using Java](http://www.baeldung.com/java-day-start-end)
 - [Generalized Target-Type Inference in Java](http://www.baeldung.com/java-generalized-target-type-inference)
-- [Calculate Age in Java](http://www.baeldung.com/java-get-age)
 - [Copy a List to Another List in Java](http://www.baeldung.com/java-copy-list-to-another)
-- [Increment Date in Java](http://www.baeldung.com/java-increment-date)
-- [Add Hours To a Date In Java](http://www.baeldung.com/java-add-hours-date)
 - [Overriding System Time for Testing in Java](http://www.baeldung.com/java-override-system-time)

core-java-8/pom.xml

@@ -89,11 +89,6 @@
             <artifactId>vavr</artifactId>
             <version>${vavr.version}</version>
         </dependency>
-        <dependency>
-            <groupId>one.util</groupId>
-            <artifactId>streamex</artifactId>
-            <version>${streamex.version}</version>
-        </dependency>
         <dependency>
             <groupId>joda-time</groupId>
             <artifactId>joda-time</artifactId>
@@ -177,7 +172,6 @@
         <lombok.version>1.16.12</lombok.version>
         <vavr.version>0.9.0</vavr.version>
         <protonpack.version>1.13</protonpack.version>
-        <streamex.version>0.6.5</streamex.version>
         <joda.version>2.10</joda.version>
         <!-- testing -->
         <assertj.version>3.6.1</assertj.version>

core-java-8/src/main/java/com/baeldung/optional/PersonRepository.java

@@ -0,0 +1,9 @@
+package com.baeldung.optional;
+
+public class PersonRepository {
+
+    public String findNameById(String id) {
+        return id == null ? null : "Name";
+    }
+
+}

core-java-8/src/main/java/com/baeldung/primitive/BenchmarkRunner.java

@@ -0,0 +1,23 @@
+package com.baeldung.primitive;
+
+public class BenchmarkRunner {
+
+    public static void main(String[] args) throws Exception {
+        new IntPrimitiveLookup().run();
+        new IntegerWrapperLookup().run();
+        new FloatPrimitiveLookup().run();
+        new FloatWrapperLookup().run();
+        new DoublePrimitiveLookup().run();
+        new DoubleWrapperLookup().run();
+        new ShortPrimitiveLookup().run();
+        new ShortWrapperLookup().run();
+        new BooleanPrimitiveLookup().run();
+        new BooleanWrapperLookup().run();
+        new CharPrimitiveLookup().run();
+        new CharacterWrapperLookup().run();
+        new BytePrimitiveLookup().run();
+        new ByteWrapperLookup().run();
+        new LongPrimitiveLookup().run();
+        new LongWrapperLookup().run();
+    }
+}

core-java-8/src/main/java/com/baeldung/primitive/BooleanPrimitiveLookup.java

@@ -0,0 +1,45 @@
+package com.baeldung.primitive;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Thread)
+public class BooleanPrimitiveLookup extends Lookup {
+
+    private boolean[] elements;
+    private final boolean pivot = false;
+
+    @Setup
+    @Override
+    public void prepare() {
+        elements = new boolean[s];
+        for (int i = 0; i < s - 1; i++) {
+            elements[i] = true;
+        }
+        elements[s - 1] = pivot;
+    }
+
+    @TearDown
+    @Override
+    public void clean() {
+        elements = null;
+    }
+
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    public int findPosition() {
+        int index = 0;
+        while (pivot != elements[index]) {
+            index++;
+        }
+        return index;
+    }
+
+    @Override
+    public String getSimpleClassName() {
+        return BooleanPrimitiveLookup.class.getSimpleName();
+    }
+
+
+
+}

core-java-8/src/main/java/com/baeldung/primitive/BooleanWrapperLookup.java

@@ -0,0 +1,45 @@
+package com.baeldung.primitive;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Thread)
+public class BooleanWrapperLookup extends Lookup {
+    private Boolean[] elements;
+    private final boolean pivot = false;
+
+    @Override
+    @Setup
+    public void prepare() {
+        elements = new Boolean[s];
+        for (int i = 0; i < s - 1; i++) {
+            elements[i] = true;
+        }
+        elements[s - 1] = pivot;
+    }
+
+    @Override
+    @TearDown
+    public void clean() {
+        elements = null;
+    }
+
+    @Override
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    public int findPosition() {
+        int index = 0;
+        Boolean pivotWrapper = pivot;
+        while (!pivotWrapper.equals(elements[index])) {
+            index++;
+        }
+        return index;
+
+    }
+
+    @Override
+    public String getSimpleClassName() {
+        return BooleanWrapperLookup.class.getSimpleName();
+    }
+
+
+}

core-java-8/src/main/java/com/baeldung/primitive/BytePrimitiveLookup.java

@@ -0,0 +1,46 @@
+package com.baeldung.primitive;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Thread)
+public class BytePrimitiveLookup extends Lookup {
+
+    private byte[] elements;
+    private final byte pivot = 2;
+
+    @Setup
+    @Override
+    public void prepare() {
+        byte common = 1;
+        elements = new byte[s];
+        for (int i = 0; i < s - 1; i++) {
+            elements[i] = common;
+        }
+        elements[s - 1] = pivot;
+    }
+
+    @TearDown
+    @Override
+    public void clean() {
+        elements = null;
+    }
+
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    public int findPosition() {
+        int index = 0;
+        while (pivot != elements[index]) {
+            index++;
+        }
+        return index;
+    }
+
+    @Override
+    public String getSimpleClassName() {
+        return BytePrimitiveLookup.class.getSimpleName();
+    }
+
+
+
+}

core-java-8/src/main/java/com/baeldung/primitive/ByteWrapperLookup.java

@@ -0,0 +1,46 @@
+package com.baeldung.primitive;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Thread)
+public class ByteWrapperLookup extends Lookup {
+    private Byte[] elements;
+    private final byte pivot = 2;
+
+    @Override
+    @Setup
+    public void prepare() {
+        byte common = 1;
+        elements = new Byte[s];
+        for (int i = 0; i < s - 1; i++) {
+            elements[i] = common;
+        }
+        elements[s - 1] = pivot;
+    }
+
+    @Override
+    @TearDown
+    public void clean() {
+        elements = null;
+    }
+
+    @Override
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    public int findPosition() {
+        int index = 0;
+        Byte pivotWrapper = pivot;
+        while (!pivotWrapper.equals(elements[index])) {
+            index++;
+        }
+        return index;
+
+    }
+
+    @Override
+    public String getSimpleClassName() {
+        return ByteWrapperLookup.class.getSimpleName();
+    }
+
+
+}

core-java-8/src/main/java/com/baeldung/primitive/CharPrimitiveLookup.java

@@ -0,0 +1,46 @@
+package com.baeldung.primitive;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Thread)
+public class CharPrimitiveLookup extends Lookup {
+
+    private char[] elements;
+    private final char pivot = 'b';
+
+    @Setup
+    @Override
+    public void prepare() {
+        char common = 'a';
+        elements = new char[s];
+        for (int i = 0; i < s - 1; i++) {
+            elements[i] = common;
+        }
+        elements[s - 1] = pivot;
+    }
+
+    @TearDown
+    @Override
+    public void clean() {
+        elements = null;
+    }
+
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    public int findPosition() {
+        int index = 0;
+        while (pivot != elements[index]) {
+            index++;
+        }
+        return index;
+    }
+
+    @Override
+    public String getSimpleClassName() {
+        return CharPrimitiveLookup.class.getSimpleName();
+    }
+
+
+
+}

core-java-8/src/main/java/com/baeldung/primitive/CharacterWrapperLookup.java

@@ -0,0 +1,46 @@
+package com.baeldung.primitive;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Thread)
+public class CharacterWrapperLookup extends Lookup {
+    private Character[] elements;
+    private final char pivot = 'b';
+
+    @Override
+    @Setup
+    public void prepare() {
+        char common = 'a';
+        elements = new Character[s];
+        for (int i = 0; i < s - 1; i++) {
+            elements[i] = common;
+        }
+        elements[s - 1] = pivot;
+    }
+
+    @Override
+    @TearDown
+    public void clean() {
+        elements = null;
+    }
+
+    @Override
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    public int findPosition() {
+        int index = 0;
+        Character pivotWrapper = pivot;
+        while (!pivotWrapper.equals(elements[index])) {
+            index++;
+        }
+        return index;
+
+    }
+
+    @Override
+    public String getSimpleClassName() {
+        return CharacterWrapperLookup.class.getSimpleName();
+    }
+
+
+}

core-java-8/src/main/java/com/baeldung/primitive/DoublePrimitiveLookup.java

@@ -0,0 +1,42 @@
+package com.baeldung.primitive;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Thread)
+public class DoublePrimitiveLookup extends Lookup {
+    private double[] elements;
+    private final double pivot = 2;
+
+    @Setup
+    @Override
+    public void prepare() {
+        double common = 1;
+        elements = new double[s];
+        for (int i = 0; i < s - 1; i++) {
+            elements[i] = common;
+        }
+        elements[s - 1] = pivot;
+    }
+
+    @TearDown
+    @Override
+    public void clean() {
+        elements = null;
+    }
+
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    public int findPosition() {
+        int index = 0;
+        while (pivot != elements[index]) {
+            index++;
+        }
+        return index;
+    }
+
+    @Override
+    public String getSimpleClassName() {
+        return DoublePrimitiveLookup.class.getSimpleName();
+    }
+}

core-java-8/src/main/java/com/baeldung/primitive/DoubleWrapperLookup.java

@@ -0,0 +1,45 @@
+package com.baeldung.primitive;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Thread)
+public class DoubleWrapperLookup extends Lookup {
+    private Double[] elements;
+    private final double pivot = 2d;
+
+    @Override
+    @Setup
+    public void prepare() {
+        double common = 1;
+        elements = new Double[s];
+        for (int i = 0; i < s - 1; i++) {
+            elements[i] = common;
+        }
+        elements[s - 1] = pivot;
+    }
+
+    @Override
+    @TearDown
+    public void clean() {
+        elements = null;
+    }
+
+    @Override
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    public int findPosition() {
+        int index = 0;
+        Double pivotWrapper = pivot;
+        while (!pivotWrapper.equals(elements[index])) {
+            index++;
+        }
+        return index;
+
+    }
+
+    @Override
+    public String getSimpleClassName() {
+        return DoubleWrapperLookup.class.getSimpleName();
+    }
+
+}

core-java-8/src/main/java/com/baeldung/primitive/FloatPrimitiveLookup.java

@@ -0,0 +1,42 @@
+package com.baeldung.primitive;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Thread)
+public class FloatPrimitiveLookup extends Lookup {
+    private float[] elements;
+    private final float pivot = 2;
+
+    @Setup
+    @Override
+    public void prepare() {
+        int common = 1;
+        elements = new float[s];
+        for (int i = 0; i < s - 1; i++) {
+            elements[i] = common;
+        }
+        elements[s - 1] = pivot;
+    }
+
+    @TearDown
+    @Override
+    public void clean() {
+        elements = null;
+    }
+
+
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    public int findPosition() {
+        int index = 0;
+        while (pivot != elements[index]) {
+            index++;
+        }
+        return index;
+    }
+
+    @Override
+    public String getSimpleClassName() {
+        return FloatPrimitiveLookup.class.getSimpleName();
+    }
+}

core-java-8/src/main/java/com/baeldung/primitive/FloatWrapperLookup.java

@@ -0,0 +1,43 @@
+package com.baeldung.primitive;
+
+import org.openjdk.jmh.annotations.*;
+
+@State(Scope.Thread)
+public class FloatWrapperLookup extends Lookup {
+    private Float[] elements;
+    private final float pivot = 2;
+
+    @Override
+    @Setup
+    public void prepare() {
+        float common = 1;
+        elements = new Float[s];
+        for (int i = 0; i < s - 1; i++) {
+            elements[i] = common;
+        }
+        elements[s - 1] = pivot;
+    }
+
+    @Override
+    @TearDown
+    public void clean() {
+        elements = null;
+    }
+
+    @Override
+    @Benchmark
+    @BenchmarkMode(Mode.AverageTime)
+    public int findPosition() {
+        int index = 0;
+        Float pivotWrapper = pivot;
+        while (!pivotWrapper.equals(elements[index])) {
+            index++;
+        }
+        return index;
+    }
+
+    @Override
+    public String getSimpleClassName() {
+        return FloatWrapperLookup.class.getSimpleName();
+    }
+}