Merge branch 'master' into master

.gitignore

@@ -42,3 +42,4 @@ spring-call-getters-using-reflection/.mvn/wrapper/maven-wrapper.properties
 
 spring-check-if-a-property-is-null/.mvn/wrapper/maven-wrapper.properties
 *.springBeans
+

algorithms/src/main/java/com/baeldung/algorithms/string/search/StringSearchAlgorithms.java

@@ -0,0 +1,194 @@
+package com.baeldung.algorithms.string.search;
+
+import java.math.BigInteger;
+import java.util.Random;
+
+public class StringSearchAlgorithms {
+    public static long getBiggerPrime(int m) {
+        BigInteger prime = BigInteger.probablePrime(getNumberOfBits(m) + 1, new Random());
+        return prime.longValue();
+    }
+
+    public static long getLowerPrime(long number) {
+        BigInteger prime = BigInteger.probablePrime(getNumberOfBits(number) - 1, new Random());
+        return prime.longValue();
+    }
+
+    private static int getNumberOfBits(final int number) {
+        return Integer.SIZE - Integer.numberOfLeadingZeros(number);
+    }
+
+    private static int getNumberOfBits(final long number) {
+        return Long.SIZE - Long.numberOfLeadingZeros(number);
+    }
+
+    public static int simpleTextSearch(char[] pattern, char[] text) {
+        int patternSize = pattern.length;
+        int textSize = text.length;
+
+        int i = 0;
+
+        while ((i + patternSize) <= textSize) {
+            int j = 0;
+            while (text[i + j] == pattern[j]) {
+                j += 1;
+                if (j >= patternSize)
+                    return i;
+            }
+            i += 1;
+        }
+
+        return -1;
+    }
+
+    public static int RabinKarpMethod(char[] pattern, char[] text) {
+        int patternSize = pattern.length; // m
+        int textSize = text.length; // n
+
+        long prime = getBiggerPrime(patternSize);
+
+        long r = 1;
+        for (int i = 0; i < patternSize - 1; i++) {
+            r *= 2;
+            r = r % prime;
+        }
+
+        long[] t = new long[textSize];
+        t[0] = 0;
+
+        long pfinger = 0;
+
+        for (int j = 0; j < patternSize; j++) {
+            t[0] = (2 * t[0] + text[j]) % prime;
+            pfinger = (2 * pfinger + pattern[j]) % prime;
+        }
+
+        int i = 0;
+        boolean passed = false;
+
+        int diff = textSize - patternSize;
+        for (i = 0; i <= diff; i++) {
+            if (t[i] == pfinger) {
+                passed = true;
+                for (int k = 0; k < patternSize; k++) {
+                    if (text[i + k] != pattern[k]) {
+                        passed = false;
+                        break;
+                    }
+                }
+
+                if (passed) {
+                    return i;
+                }
+            }
+
+            if (i < diff) {
+                long value = 2 * (t[i] - r * text[i]) + text[i + patternSize];
+                t[i + 1] = ((value % prime) + prime) % prime;
+            }
+        }
+        return -1;
+
+    }
+
+    public static int KnuthMorrisPrattSearch(char[] pattern, char[] text) {
+        int patternSize = pattern.length; // m
+        int textSize = text.length; // n
+
+        int i = 0, j = 0;
+
+        int[] shift = KnuthMorrisPrattShift(pattern);
+
+        while ((i + patternSize) <= textSize) {
+            while (text[i + j] == pattern[j]) {
+                j += 1;
+                if (j >= patternSize)
+                    return i;
+            }
+
+            if (j > 0) {
+                i += shift[j - 1];
+                j = Math.max(j - shift[j - 1], 0);
+            } else {
+                i++;
+                j = 0;
+            }
+        }
+        return -1;
+    }
+
+    public static int[] KnuthMorrisPrattShift(char[] pattern) {
+        int patternSize = pattern.length;
+
+        int[] shift = new int[patternSize];
+        shift[0] = 1;
+
+        int i = 1, j = 0;
+
+        while ((i + j) < patternSize) {
+            if (pattern[i + j] == pattern[j]) {
+                shift[i + j] = i;
+                j++;
+            } else {
+                if (j == 0)
+                    shift[i] = i + 1;
+
+                if (j > 0) {
+                    i = i + shift[j - 1];
+                    j = Math.max(j - shift[j - 1], 0);
+                } else {
+                    i = i + 1;
+                    j = 0;
+                }
+            }
+        }
+        return shift;
+    }
+
+    public static int BoyerMooreHorspoolSimpleSearch(char[] pattern, char[] text) {
+        int patternSize = pattern.length;
+        int textSize = text.length;
+
+        int i = 0, j = 0;
+
+        while ((i + patternSize) <= textSize) {
+            j = patternSize - 1;
+            while (text[i + j] == pattern[j]) {
+                j--;
+                if (j < 0)
+                    return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    public static int BoyerMooreHorspoolSearch(char[] pattern, char[] text) {
+
+        int shift[] = new int[256];
+
+        for (int k = 0; k < 256; k++) {
+            shift[k] = pattern.length;
+        }
+
+        for (int k = 0; k < pattern.length - 1; k++) {
+            shift[pattern[k]] = pattern.length - 1 - k;
+        }
+
+        int i = 0, j = 0;
+
+        while ((i + pattern.length) <= text.length) {
+            j = pattern.length - 1;
+
+            while (text[i + j] == pattern[j]) {
+                j -= 1;
+                if (j < 0)
+                    return i;
+            }
+
+            i = i + shift[text[i + pattern.length - 1]];
+
+        }
+        return -1;
+    }
+}

algorithms/src/test/java/algorithms/StringSearchAlgorithmsTest.java

@@ -0,0 +1,25 @@
+package algorithms;
+
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.baeldung.algorithms.string.search.StringSearchAlgorithms;
+
+public class StringSearchAlgorithmsTest {
+	
+	
+	@Test
+	public void testStringSearchAlgorithms(){
+		String text = "This is some nice text.";
+		String pattern = "some";
+		
+		int realPosition = text.indexOf(pattern);
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.simpleTextSearch(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.RabinKarpMethod(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.KnuthMorrisPrattSearch(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.BoyerMooreHorspoolSimpleSearch(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.BoyerMooreHorspoolSearch(pattern.toCharArray(), text.toCharArray()));
+	}
+
+}

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 {
         }
     }
 
-}
+}

core-java-8/src/test/resources/.gitignore

@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear

core-java-concurrency/src/main/java/com/baeldung/concurrent/callable/FactorialTask.java

@@ -0,0 +1,30 @@
+package com.baeldung.concurrent.callable;
+
+
+import java.util.concurrent.Callable;
+
+public class FactorialTask implements Callable<Integer> {
+    int number;
+
+    public FactorialTask(int number) {
+        this.number = number;
+    }
+
+    public Integer call() throws InvalidParamaterException {
+        int fact=1;
+        if(number < 0)
+            throw new InvalidParamaterException("Number must be positive");
+
+        for(int count=number;count>1;count--){
+            fact=fact * count;
+        }
+
+        return fact;
+    }
+
+    private class InvalidParamaterException extends Exception {
+        public InvalidParamaterException(String message) {
+            super(message);
+        }
+    }
+}

core-java-concurrency/src/main/java/com/baeldung/concurrent/runnable/EventLoggingTask.java

@@ -0,0 +1,17 @@
+package com.baeldung.concurrent.runnable;
+
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class EventLoggingTask implements  Runnable{
+    private Logger logger = LoggerFactory.getLogger(EventLoggingTask.class);
+
+    @Override
+    public void run() {
+
+        String messge="Message read from the event queue";
+        logger.info("Message read from event queue is "+messge);
+
+    }
+}

core-java-concurrency/src/main/java/com/baeldung/concurrent/runnable/TaskRunner.java

@@ -0,0 +1,25 @@
+package com.baeldung.concurrent.runnable;
+
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+public class TaskRunner {
+
+    private static ExecutorService executorService;
+
+    public static void main(String[] args) {
+        executeTask();
+    }
+
+    private static void executeTask() {
+        executorService= Executors.newSingleThreadExecutor();
+
+        EventLoggingTask task = new EventLoggingTask();
+
+        Future future = executorService.submit(task);
+
+        executorService.shutdown();
+    }
+}

core-java-concurrency/src/main/java/com/baeldung/threadpool/TreeNode.java

@@ -22,4 +22,4 @@ public class TreeNode {
     public Set<TreeNode> getChildren() {
         return children;
     }
-}
+}

core-java-concurrency/src/test/java/com/baeldung/concurrent/callable/FactorialTaskManualTest.java

@@ -0,0 +1,48 @@
+package com.baeldung.concurrent.callable;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import static junit.framework.Assert.assertEquals;
+
+public class FactorialTaskManualTest {
+
+    private ExecutorService executorService;
+
+    @Before
+    public void setup(){
+        executorService = Executors.newSingleThreadExecutor();
+    }
+
+    @Test
+    public void whenTaskSubmitted_ThenFutureResultObtained() throws ExecutionException, InterruptedException {
+        FactorialTask task = new FactorialTask(5);
+        Future<Integer> future= executorService.submit(task);
+        assertEquals(120,future.get().intValue());
+    }
+
+    @Test(expected = ExecutionException.class)
+    public void whenException_ThenCallableThrowsIt() throws ExecutionException, InterruptedException {
+        FactorialTask task = new FactorialTask(-5);
+        Future<Integer> future= executorService.submit(task);
+        Integer result=future.get().intValue();
+    }
+
+    @Test
+    public void whenException_ThenCallableDoesntThrowsItIfGetIsNotCalled(){
+        FactorialTask task = new FactorialTask(-5);
+        Future<Integer> future= executorService.submit(task);
+        assertEquals(false,future.isDone());
+    }
+
+    @After
+    public void cleanup(){
+        executorService.shutdown();
+    }
+}

core-java/README.md

@@ -22,19 +22,11 @@
 - [Guide to the Java ArrayList](http://www.baeldung.com/java-arraylist)
 - [Guide to Java Reflection](http://www.baeldung.com/java-reflection)
 - [A Guide to Java Sockets](http://www.baeldung.com/a-guide-to-java-sockets)
-- [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)
 - [Convert char to String in Java](http://www.baeldung.com/java-convert-char-to-string)
 - [Random List Element](http://www.baeldung.com/java-random-list-element)
 - [Convert String to int or Integer in Java](http://www.baeldung.com/java-convert-string-to-int-or-integer)
-- [Java 8 – Powerful Comparison with Lambdas](http://www.baeldung.com/java-8-sort-lambda)
 - [Java – Directory Size](http://www.baeldung.com/java-folder-size)
 - [Java – Try with Resources](http://www.baeldung.com/java-try-with-resources)
-- [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 the Fork/Join Framework in Java](http://www.baeldung.com/java-fork-join)
 - [How to Print Screen in Java](http://www.baeldung.com/print-screen-in-java)
 - [How to Convert String to different data types in Java](http://www.baeldung.com/java-string-conversions)
@@ -55,30 +47,20 @@
 - [The Traveling Salesman Problem in Java](http://www.baeldung.com/java-simulated-annealing-for-traveling-salesman)
 - [How to Create an Executable JAR with Maven](http://www.baeldung.com/executable-jar-with-maven)
 - [How to Design a Genetic Algorithm in Java](http://www.baeldung.com/java-genetic-algorithm)
-- [Guide to Java 8 groupingBy Collector](http://www.baeldung.com/java-groupingby-collector)
 - [Guide to WeakHashMap in Java](http://www.baeldung.com/java-weakhashmap)
-- [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)
 - [Spring Security – Cache Control Headers](http://www.baeldung.com/spring-security-cache-control-headers)
 - [Basic Introduction to JMX](http://www.baeldung.com/java-management-extensions)
 - [AWS Lambda With Java](http://www.baeldung.com/java-aws-lambda)
 - [Introduction to Nashorn](http://www.baeldung.com/java-nashorn)
-- [Exceptions in Java 8 Lambda Expressions](http://www.baeldung.com/java-lambda-exceptions)
 - [Guide to the Guava BiMap](http://www.baeldung.com/guava-bimap)
 - [Iterable to Stream in Java](http://www.baeldung.com/java-iterable-to-stream)
-- [Java 8 Stream findFirst() vs. findAny()](http://www.baeldung.com/java-stream-findfirst-vs-findany)
 - [Chained Exceptions in Java](http://www.baeldung.com/java-chained-exceptions)
 - [The Java HashMap Under the Hood](http://www.baeldung.com/java-hashmap)
 - [A Guide to LinkedHashMap in Java](http://www.baeldung.com/java-linked-hashmap)
 - [A Guide to TreeMap in Java](http://www.baeldung.com/java-treemap)
 - [A Quick JUnit vs TestNG Comparison](http://www.baeldung.com/junit-vs-testng)
-- [Finding Max/Min of a List or Collection](http://www.baeldung.com/java-collection-min-max)
-- [Guide to java.util.concurrent.Locks](http://www.baeldung.com/java-concurrent-locks)
 - [Java Primitive Conversions](http://www.baeldung.com/java-primitive-conversions)
 - [Java Money and the Currency API](http://www.baeldung.com/java-money-and-currency)
-- [Guide to Java 8 Comparator.comparing()](http://www.baeldung.com/java-8-comparator-comparing)
-- [Avoiding ConcurrentModificationException when iterating and removing](http://www.baeldung.com/avoiding-concurrentmodificationexception-when-iterating-and-removing)
 - [Removing all nulls from a List in Java](http://www.baeldung.com/java-remove-nulls-from-list)
 - [Removing all duplicates from a List in Java](http://www.baeldung.com/java-remove-duplicates-from-list)
 - [Using Math.pow in Java](http://www.baeldung.com/java-math-pow)
@@ -96,7 +78,6 @@
 - [Iterating Over Enum Values in Java](http://www.baeldung.com/java-enum-iteration)
 - [Kotlin Java Interoperability](http://www.baeldung.com/kotlin-java-interoperability)
 - [Using Java MappedByteBuffer](http://www.baeldung.com/java-mapped-byte-buffer)
-- [The Difference Between map() and flatMap()](http://www.baeldung.com/java-difference-map-and-flatmap)
 - [How to Round a Number to N Decimal Places in Java](http://www.baeldung.com/java-round-decimal-number)
 - [Changing Annotation Parameters At Runtime](http://www.baeldung.com/java-reflection-change-annotation-params)
 - [How to Find all Getters Returning Null](http://www.baeldung.com/java-getters-returning-null)
@@ -117,8 +98,5 @@
 - [How to Remove the Last Character of a String?](http://www.baeldung.com/java-remove-last-character-of-string)
 - [ClassNotFoundException vs NoClassDefFoundError](http://www.baeldung.com/java-classnotfoundexception-and-noclassdeffounderror)
 - [Guide to UUID in Java](http://www.baeldung.com/java-uuid)
-- [How to Get the Last Element of a Stream in Java?](http://www.baeldung.com/java-stream-last-element)
 - [Guide to Escaping Characters in Java RegExps](http://www.baeldung.com/java-regexp-escape-char)
 - [Period and Duration in Java](http://www.baeldung.com/java-period-duration)
-- [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)

core-java/pom.xml

@@ -187,14 +187,14 @@
             <version>${fscontext.version}</version>
         </dependency>
         <dependency>
-            <groupId>joda-time</groupId>
-            <artifactId>joda-time</artifactId>
-            <version>${joda-time.version}</version>
+            <groupId>com.codepoetics</groupId>
+            <artifactId>protonpack</artifactId>
+            <version>${protonpack.version}</version>
         </dependency>
         <dependency>
-            <groupId>com.darwinsys</groupId>
-            <artifactId>hirondelle-date4j</artifactId>
-            <version>${hirondelle-date4j.version}</version>
+            <groupId>one.util</groupId>
+            <artifactId>streamex</artifactId>
+            <version>${streamex.version}</version>
         </dependency>
     </dependencies>
 
@@ -418,8 +418,8 @@
         <grep4j.version>1.8.7</grep4j.version>
         <lombok.version>1.16.12</lombok.version>
         <fscontext.version>4.6-b01</fscontext.version>
-        <joda-time.version>2.9.9</joda-time.version>
-        <hirondelle-date4j.version>1.5.1</hirondelle-date4j.version>
+        <protonpack.version>1.13</protonpack.version>
+        <streamex.version>0.6.5</streamex.version>
 
         <!-- testing -->
         <org.hamcrest.version>1.3</org.hamcrest.version>
@@ -428,7 +428,6 @@
         <assertj.version>3.6.1</assertj.version>
         <avaitility.version>1.7.0</avaitility.version>
 
-
         <!-- maven plugins -->
         <maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
         <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>