Merge remote-tracking branch 'origin/master'

.travis.yml

@@ -1,16 +1,12 @@
 language: java
 
 before_install: 
-  - export MAVEN_OPTS="-Xmx2048M -Xss128M -XX:+CMSClassUnloadingEnabled -XX:+UseG1GC -XX:-UseGCOverheadLimit"
   - echo "MAVEN_OPTS='-Xmx2048M -Xss128M -XX:+CMSClassUnloadingEnabled -XX:+UseG1GC -XX:-UseGCOverheadLimit'" > ~/.mavenrc
 
 install: travis_wait 60 mvn -q test -fae
 
 sudo: required
 
-before_script:
-  - echo "MAVEN_OPTS='-Xmx2048M -Xss128M -XX:+CMSClassUnloadingEnabled -XX:+UseG1GC -XX:-UseGCOverheadLimit'" > ~/.mavenrc
-
 jdk:
   - oraclejdk8
 

core-java-9/pom.xml

@@ -47,6 +47,13 @@
             <version>${mockito.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.jayway.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>${awaitility.version}</version>
+            <scope>test</scope>
+        </dependency>
+
 
     </dependencies>
 
@@ -90,6 +97,7 @@
         <org.hamcrest.version>1.3</org.hamcrest.version>
         <junit.version>4.12</junit.version>
         <mockito.version>1.10.19</mockito.version>
+        <awaitility.version>1.7.0</awaitility.version>
     </properties>
 
 </project>

core-java-9/src/main/java/com/baeldung/java9/streams.reactive/EndSubscriber.java

@@ -0,0 +1,43 @@
+package com.baeldung.java9.streams.reactive;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.Flow.Subscriber;
+import java.util.concurrent.Flow.Subscription;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class EndSubscriber<T> implements Subscriber<T> {
+    private final AtomicInteger howMuchMessagesToConsume;
+    private Subscription subscription;
+    public List<T> consumedElements = new LinkedList<>();
+
+    public EndSubscriber(Integer howMuchMessagesToConsume) {
+        this.howMuchMessagesToConsume = new AtomicInteger(howMuchMessagesToConsume);
+    }
+
+    @Override
+    public void onSubscribe(Subscription subscription) {
+        this.subscription = subscription;
+        subscription.request(1);
+    }
+
+    @Override
+    public void onNext(T item) {
+        howMuchMessagesToConsume.decrementAndGet();
+        System.out.println("Got : " + item);
+        consumedElements.add(item);
+        if (howMuchMessagesToConsume.get() > 0) {
+            subscription.request(1);
+        }
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        t.printStackTrace();
+    }
+
+    @Override
+    public void onComplete() {
+        System.out.println("Done");
+    }
+}

core-java-9/src/main/java/com/baeldung/java9/streams.reactive/TransformProcessor.java

@@ -0,0 +1,38 @@
+package com.baeldung.java9.streams.reactive;
+
+import java.util.concurrent.Flow;
+import java.util.concurrent.SubmissionPublisher;
+import java.util.function.Function;
+
+public class TransformProcessor<T, R> extends SubmissionPublisher<R> implements Flow.Processor<T, R> {
+
+    private Function<T, R> function;
+    private Flow.Subscription subscription;
+
+    public TransformProcessor(Function<T, R> function) {
+        super();
+        this.function = function;
+    }
+
+    @Override
+    public void onSubscribe(Flow.Subscription subscription) {
+        this.subscription = subscription;
+        subscription.request(1);
+    }
+
+    @Override
+    public void onNext(T item) {
+        submit(function.apply(item));
+        subscription.request(1);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        t.printStackTrace();
+    }
+
+    @Override
+    public void onComplete() {
+        close();
+    }
+}  

core-java-9/src/test/java/com/baeldung/java9/Java9OptionalTest.java

@@ -0,0 +1,85 @@
+package com.baeldung.java9;
+
+public class Java9OptionalTest {
+    @Test
+    public void givenOptionalOfSome_whenToStream_thenShouldTreatItAsOneElementStream() {
+        //given
+        Optional<String> value = Optional.of("a");
+
+        //when
+        List<String> collect = value.stream().map(String::toUpperCase).collect(Collectors.toList());
+
+        //then
+        assertThat(collect).hasSameElementsAs(List.of("A"));
+    }
+
+    @Test
+    public void givenOptionalOfNone_whenToStream_thenShouldTreatItAsZeroElementStream() {
+        //given
+        Optional<String> value = Optional.empty();
+
+        //when
+        List<String> collect = value.stream().map(String::toUpperCase).collect(Collectors.toList());
+
+        //then
+        assertThat(collect).isEmpty();
+    }
+
+    @Test
+    public void givenOptional_whenPresent_thenShouldExecuteProperCallback() {
+        //given
+        Optional<String> value = Optional.of("properValue");
+        AtomicInteger successCounter = new AtomicInteger(0);
+        AtomicInteger onEmptyOptionalCounter = new AtomicInteger(0);
+
+        //when
+        value.ifPresentOrElse((v) -> successCounter.incrementAndGet(), onEmptyOptionalCounter::incrementAndGet);
+
+        //then
+        assertThat(successCounter.get()).isEqualTo(1);
+        assertThat(onEmptyOptionalCounter.get()).isEqualTo(0);
+    }
+
+    @Test
+    public void givenOptional_whenNotPresent_thenShouldExecuteProperCallback() {
+        //given
+        Optional<String> value = Optional.empty();
+        AtomicInteger successCounter = new AtomicInteger(0);
+        AtomicInteger onEmptyOptionalCounter = new AtomicInteger(0);
+
+        //when
+        value.ifPresentOrElse((v) -> successCounter.incrementAndGet(), onEmptyOptionalCounter::incrementAndGet);
+
+        //then
+        assertThat(successCounter.get()).isEqualTo(0);
+        assertThat(onEmptyOptionalCounter.get()).isEqualTo(1);
+    }
+
+    @Test
+    public void givenOptional_whenPresent_thenShouldTakeAValueFromIt() {
+        //given
+        String expected = "properValue";
+        Optional<String> value = Optional.of(expected);
+        Optional<String> defaultValue = Optional.of("default");
+
+        //when
+        Optional<String> result = value.or(() -> defaultValue);
+
+        //then
+        assertThat(result.get()).isEqualTo(expected);
+    }
+
+    @Test
+    public void givenOptional_whenEmpty_thenShouldTakeAValueFromOr() {
+        //given
+        String defaultString = "default";
+        Optional<String> value = Optional.empty();
+        Optional<String> defaultValue = Optional.of(defaultString);
+
+        //when
+        Optional<String> result = value.or(() -> defaultValue);
+
+        //then
+        assertThat(result.get()).isEqualTo(defaultString);
+    }
+}

core-java-9/src/test/java/com/baeldung/java9/streams.reactive/ReactiveStreamsTest.java

@@ -0,0 +1,73 @@
+package com.baeldung.java9.streams.reactive;
+
+
+import org.junit.Test;
+
+import java.util.List;
+import java.util.concurrent.SubmissionPublisher;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+
+public class ReactiveStreamsTest {
+
+    @Test
+    public void givenPublisher_whenSubscribeToIt_thenShouldConsumeAllElements() throws InterruptedException {
+        //given
+        SubmissionPublisher<String> publisher = new SubmissionPublisher<>();
+        EndSubscriber<String> subscriber = new EndSubscriber<>(6);
+        publisher.subscribe(subscriber);
+        List<String> items = List.of("1", "x", "2", "x", "3", "x");
+
+        //when
+        assertThat(publisher.getNumberOfSubscribers()).isEqualTo(1);
+        items.forEach(publisher::submit);
+        publisher.close();
+
+        //then
+
+        await().atMost(1000, TimeUnit.MILLISECONDS).until(
+                () -> assertThat(subscriber.consumedElements).containsExactlyElementsOf(items)
+        );
+    }
+
+    @Test
+    public void givenPublisher_whenSubscribeAndTransformElements_thenShouldConsumeAllElements() throws InterruptedException {
+        //given
+        SubmissionPublisher<String> publisher = new SubmissionPublisher<>();
+        TransformProcessor<String, Integer> transformProcessor = new TransformProcessor<>(Integer::parseInt);
+        EndSubscriber<Integer> subscriber = new EndSubscriber<>(3);
+        List<String> items = List.of("1", "2", "3");
+        List<Integer> expectedResult = List.of(1, 2, 3);
+
+        //when
+        publisher.subscribe(transformProcessor);
+        transformProcessor.subscribe(subscriber);
+        items.forEach(publisher::submit);
+        publisher.close();
+
+        //then
+        await().atMost(1000, TimeUnit.MILLISECONDS).until(
+                () -> assertThat(subscriber.consumedElements).containsExactlyElementsOf(expectedResult)
+        );
+    }
+
+    @Test
+    public void givenPublisher_whenRequestForOnlyOneElement_thenShouldConsumeOnlyThatOne() throws InterruptedException {
+        //given
+        SubmissionPublisher<String> publisher = new SubmissionPublisher<>();
+        EndSubscriber<String> subscriber = new EndSubscriber<>(1);
+        publisher.subscribe(subscriber);
+        List<String> items = List.of("1", "x", "2", "x", "3", "x");
+        List<String> expected = List.of("1");
+
+        //when
+        assertThat(publisher.getNumberOfSubscribers()).isEqualTo(1);
+        items.forEach(publisher::submit);
+        publisher.close();
+
+        //then
+        await().atMost(1000, TimeUnit.MILLISECONDS).until(
+                () -> assertThat(subscriber.consumedElements).containsExactlyElementsOf(expected)
+        );
+    }
+}

core-java/README.md

@@ -102,3 +102,15 @@
 - [How to Perform a Simple HTTP Request in Java](http://www.baeldung.com/java-http-request)
 - [Call Methods at Runtime Using Java Reflection](http://www.baeldung.com/java-method-reflection)
 - [Guide to DelayQueue](http://www.baeldung.com/java-delay-queue)
+- [Guide to UUID in JAVA](http://www.baeldung.com/guide-to-uuid-in-java)
+- [Comparing getPath(), getAbsolutePath(), and getCanonicalPath() in Java](http://www.baeldung.com/java-path)
+- [How to Add a Single Element to a Stream](http://www.baeldung.com/java-stream-append-prepend)
+- [Iterating Over Enum Values in Java](http://www.baeldung.com/java-enum-iteration)
+- [A Guide to Java SynchronousQueue](http://www.baeldung.com/java-synchronous-queue)
+- [Guide to the Java TransferQueue](http://www.baeldung.com/java-transfer-queue)
+- [Kotlin Java Interoperability](http://www.baeldung.com/kotlin-java-interoperability)
+- [Guide to the ConcurrentSkipListMap](http://www.baeldung.com/java-concurrent-skip-list-map)
+- [Difference Between Wait and Sleep in Java](http://www.baeldung.com/java-wait-and-sleep)
+- [LongAdder and LongAccumulator in Java](http://www.baeldung.com/java-longadder-and-longaccumulator)
+- [Using Java MappedByteBuffer](http://www.baeldung.com/java-mapped-byte-buffer)
+

core-java/pom.xml

@@ -45,6 +45,12 @@
 			<artifactId>commons-math3</artifactId>
 			<version>${commons-math3.version}</version>
 		</dependency>
+		
+		<dependency>
+    		<groupId>org.decimal4j</groupId>
+    		<artifactId>decimal4j</artifactId>
+    		<version>${decimal4j.version}</version>
+		</dependency>
 
 		<dependency>
 			<groupId>org.bouncycastle</groupId>
@@ -369,6 +375,7 @@
 		<bouncycastle.version>1.55</bouncycastle.version>
 		<commons-codec.version>1.10</commons-codec.version>
 		<commons-math3.version>3.6.1</commons-math3.version>
+		<decimal4j.version>1.0.3</decimal4j.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>

core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/DiningPhilosophers.java

@@ -0,0 +1,29 @@
+package com.baeldung.concurrent.diningphilosophers;
+
+public class DiningPhilosophers {
+
+    public static void main(String[] args) throws Exception {
+
+        Philosopher[] philosophers = new Philosopher[5];
+        Object[] forks = new Object[philosophers.length];
+
+        for (int i = 0; i < forks.length; i++) {
+            forks[i] = new Object();
+        }
+
+        for (int i = 0; i < philosophers.length; i++) {
+
+            Object leftFork = forks[i];
+            Object rightFork = forks[(i + 1) % forks.length];
+
+            if (i == philosophers.length - 1) {
+                philosophers[i] = new Philosopher(rightFork, leftFork); // The last philosopher picks up the right fork first
+            } else {
+                philosophers[i] = new Philosopher(leftFork, rightFork);
+            }
+
+            Thread t = new Thread(philosophers[i], "Philosopher " + (i + 1));
+            t.start();
+        }
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/diningphilosophers/Philosopher.java

@@ -0,0 +1,36 @@
+package com.baeldung.concurrent.diningphilosophers;
+
+public class Philosopher implements Runnable {
+
+    private final Object leftFork;
+    private final Object rightFork;
+
+    public Philosopher(Object left, Object right) {
+        this.leftFork = left;
+        this.rightFork = right;
+    }
+
+    private void doAction(String action) throws InterruptedException {
+        System.out.println(Thread.currentThread().getName() + " " + action);
+        Thread.sleep(((int) (Math.random() * 100)));
+    }
+
+    @Override public void run() {
+        try {
+            while (true) {
+                doAction(System.nanoTime() + ": Thinking"); // thinking
+                synchronized (leftFork) {
+                    doAction(System.nanoTime() + ": Picked up left fork");
+                    synchronized (rightFork) {
+                        doAction(System.nanoTime() + ": Picked up right fork - eating"); // eating
+                        doAction(System.nanoTime() + ": Put down right fork");
+                    }
+                    doAction(System.nanoTime() + ": Put down left fork. Returning to thinking");
+                }
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return;
+        }
+    }
+}

core-java/src/main/java/com/baeldung/java/enumiteration/DaysOfWeekEnum.java

@@ -0,0 +1,31 @@
+package com.baeldung.java.enumiteration;
+
+import java.util.stream.Stream;
+
+public enum DaysOfWeekEnum {
+	SUNDAY("off"), 
+	MONDAY("working"), 
+	TUESDAY("working"), 
+	WEDNESDAY("working"), 
+	THURSDAY("working"), 
+	FRIDAY("working"), 
+	SATURDAY("off");
+
+	private String typeOfDay;
+
+	DaysOfWeekEnum(String typeOfDay) {
+		this.typeOfDay = typeOfDay;
+	}
+	
+	public String getTypeOfDay() {
+		return typeOfDay;
+	}
+
+	public void setTypeOfDay(String typeOfDay) {
+		this.typeOfDay = typeOfDay;
+	}
+
+	public static Stream<DaysOfWeekEnum> stream() {
+		return Stream.of(DaysOfWeekEnum.values());
+	}
+}

core-java/src/main/java/com/baeldung/java/enumiteration/EnumIterationExamples.java

@@ -0,0 +1,18 @@
+package com.baeldung.java.enumiteration;
+
+import java.util.EnumSet;
+
+public class EnumIterationExamples {
+	public static void main(String[] args) {
+		System.out.println("Enum iteration using forEach:");
+		EnumSet.allOf(DaysOfWeekEnum.class).forEach(day -> System.out.println(day));
+
+		System.out.println("Enum iteration using Stream:");
+		DaysOfWeekEnum.stream().filter(d -> d.getTypeOfDay().equals("off")).forEach(System.out::println);
+
+		System.out.println("Enum iteration using for loop:");
+		for (DaysOfWeekEnum day : DaysOfWeekEnum.values()) {
+			System.out.println(day);
+		}
+	}
+}

core-java/src/main/java/com/baeldung/maths/Round.java

@@ -0,0 +1,47 @@
+package com.baeldung.maths;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+
+import org.apache.commons.math3.util.Precision;
+import org.decimal4j.util.DoubleRounder;
+
+public class Round {
+    private static final double PI = 3.1415d;
+    
+    public static void main (String args[]) {
+        System.out.println("PI: " + PI);
+        System.out.printf("Value with 3 digits after decimal point %.3f %n", PI);
+        // OUTPUTS: Value with 3 digits after decimal point 3.142
+        DecimalFormat df = new DecimalFormat("###.###");
+        System.out.println(df.format(PI));
+        System.out.println(round(PI, 3));
+        System.out.println(roundNotPrecise(PI, 3));
+        System.out.println(roundAvoid(PI, 3));
+        System.out.println(Precision.round(PI, 3));
+        System.out.println(DoubleRounder.round(PI, 3));
+    }
+    
+    public static double round(double value, int places) {
+        if (places < 0) throw new IllegalArgumentException();
+        
+        BigDecimal bd = new BigDecimal(Double.toString(value));
+        bd = bd.setScale(places, RoundingMode.HALF_UP);
+        return bd.doubleValue();
+    }
+    
+    public static double roundNotPrecise(double value, int places) {
+        if (places < 0) throw new IllegalArgumentException();
+
+        BigDecimal bd = new BigDecimal(value);
+        bd = bd.setScale(places, RoundingMode.HALF_UP);
+        return bd.doubleValue();
+    }
+    
+    public static double roundAvoid(double value, int places) {
+        double scale = Math.pow(10, places);
+        double rounded = Math.round(value * scale) / scale;
+        return rounded;
+    }
+}

core-java/src/main/java/com/baeldung/noclassdeffounderror/ClassWithInitErrors.java

@@ -0,0 +1,5 @@
+package com.baeldung.noclassdeffounderror;
+
+public class ClassWithInitErrors {
+    static int data = 1 / 0;
+}

core-java/src/main/java/com/baeldung/noclassdeffounderror/NoClassDefFoundErrorExample.java

@@ -0,0 +1,14 @@
+package com.baeldung.noclassdeffounderror;
+
+public class NoClassDefFoundErrorExample {
+    public ClassWithInitErrors getClassWithInitErrors() {
+        ClassWithInitErrors test;
+        try {
+            test = new ClassWithInitErrors();
+        } catch (Throwable t) {
+            System.out.println(t);
+        }
+        test = new ClassWithInitErrors();
+        return test;
+    }
+}

core-java/src/main/java/com/baeldung/stream/StreamApi.java

@@ -0,0 +1,24 @@
+package com.baeldung.stream;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+public class StreamApi {
+
+    public String getLastElementUsingReduce(List<String> valueList) {
+        Stream<String> stream = valueList.stream();
+        return stream.reduce((first, second) -> second).orElse(null);
+    }
+    
+    public Integer getInfiniteStreamLastElementUsingReduce() {
+        Stream<Integer> stream = Stream.iterate(0, i -> i + 1);
+        return stream.limit(20).reduce((first, second) -> second).orElse(null);
+    }
+    
+    public String getLastElementUsingSkip(List<String> valueList) {
+        long count = valueList.stream().count();
+        Stream<String> stream = valueList.stream();
+        return stream.skip(count - 1).findFirst().orElse(null);
+    }
+
+}

core-java/src/main/java/com/baeldung/string/StringHelper.java

@@ -2,23 +2,23 @@ package com.baeldung.string;
 
 import java.util.Optional;
 
-public class StringHelper {
-    public static String removeLastChar(String s) {
+class StringHelper {
+    static String removeLastChar(String s) {
         return (s == null || s.length() == 0) ? s : (s.substring(0, s.length() - 1));
     }
 
-    public static String removeLastCharRegex(String s) {
+    static String removeLastCharRegex(String s) {
         return (s == null) ? s : s.replaceAll(".$", "");
     }
 
-    public static String removeLastCharOptional(String s) {
+    static String removeLastCharOptional(String s) {
         return Optional.ofNullable(s)
             .filter(str -> str.length() != 0)
             .map(str -> str.substring(0, str.length() - 1))
             .orElse(s);
     }
 
-    public static String removeLastCharRegexOptional(String s) {
+    static String removeLastCharRegexOptional(String s) {
         return Optional.ofNullable(s)
             .map(str -> str.replaceAll(".$", ""))
             .orElse(s);

core-java/src/main/java/com/baeldung/uuid/UUIDGenerator.java

@@ -0,0 +1,118 @@
+package com.baeldung.uuid;
+
+import java.io.UnsupportedEncodingException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.UUID;
+
+public class UUIDGenerator {
+    
+    /**
+     * These are predefined UUID for name spaces
+     */
+    private static final String NAMESPACE_DNS   = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+    private static final String NAMESPACE_URL   = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+    private static final String NAMESPACE_OID   = "6ba7b812-9dad-11d1-80b4-00c04fd430c8";
+    private static final String NAMESPACE_X500  = "6ba7b814-9dad-11d1-80b4-00c04fd430c8";
+
+    private static final  char[] hexArray = "0123456789ABCDEF".toCharArray();
+
+    public static void main(String[] args) {
+        try {
+            System.out.println("Type 3 : " + generateType3UUID(NAMESPACE_DNS, "google.com"));
+            System.out.println("Type 4 : " + generateType4UUID());
+            System.out.println("Type 5 : " + generateType5UUID(NAMESPACE_URL, "google.com"));
+            System.out.println("Unique key  : " + generateUniqueKeysWithUUIDAndMessageDigest());
+        } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Type 4 UUID Generation
+     */
+    public static UUID generateType4UUID() {
+        UUID uuid = UUID.randomUUID();
+        return uuid;
+    }
+    
+    /**
+     * Type 3 UUID Generation
+     * 
+     * @throws UnsupportedEncodingException 
+     */
+    public static UUID generateType3UUID(String namespace, String name) throws UnsupportedEncodingException {
+        String source = namespace + name;
+        byte[] bytes = source.getBytes("UTF-8");
+        UUID uuid = UUID.nameUUIDFromBytes(bytes);
+        return uuid;
+    }
+    
+    /**
+     * Type 5 UUID Generation
+     * 
+     * @throws UnsupportedEncodingException 
+     */
+    public static UUID generateType5UUID(String namespace, String name) throws UnsupportedEncodingException {
+        String source = namespace + name;
+        byte[] bytes = source.getBytes("UTF-8");
+        UUID uuid = type5UUIDFromBytes(bytes);
+        return uuid;
+    }
+    
+    
+    public static UUID type5UUIDFromBytes(byte[] name) {
+        MessageDigest md;
+        try {
+            md = MessageDigest.getInstance("SHA-1");
+        } catch (NoSuchAlgorithmException nsae) {
+            throw new InternalError("MD5 not supported", nsae);
+        }
+        byte[] bytes = md.digest(name);
+        bytes[6]  &= 0x0f;  /* clear version        */
+        bytes[6]  |= 0x50;  /* set to version 5     */
+        bytes[8]  &= 0x3f;  /* clear variant        */
+        bytes[8]  |= 0x80;  /* set to IETF variant  */
+        return constructType5UUID(bytes);
+    }
+    
+    private static UUID constructType5UUID(byte[] data) {
+        long msb = 0;
+        long lsb = 0;
+        assert data.length == 16 : "data must be 16 bytes in length";
+        
+        for (int i=0; i<8; i++)
+            msb = (msb << 8) | (data[i] & 0xff);
+        
+        for (int i=8; i<16; i++)
+            lsb = (lsb << 8) | (data[i] & 0xff);
+        return new UUID(msb, lsb);
+    }
+
+    
+    /**
+     * Unique Keys Generation Using Message Digest and Type 4 UUID
+     * 
+     * @throws NoSuchAlgorithmException 
+     * @throws UnsupportedEncodingException 
+     */
+    public static String generateUniqueKeysWithUUIDAndMessageDigest() throws NoSuchAlgorithmException, UnsupportedEncodingException {
+        MessageDigest salt = MessageDigest.getInstance("SHA-256");
+        salt.update(UUID.randomUUID()
+            .toString()
+            .getBytes("UTF-8"));
+        String digest = bytesToHex(salt.digest());
+        return digest;
+    }
+
+    public static String bytesToHex(byte[] bytes) {
+        char[] hexChars = new char[bytes.length * 2];
+        for (int j = 0; j < bytes.length; j++) {
+            int v = bytes[j] & 0xFF;
+            hexChars[j * 2] = hexArray[v >>> 4];
+            hexChars[j * 2 + 1] = hexArray[v & 0x0F];
+        }
+        return new String(hexChars);
+    }
+
+}

core-java/src/test/java/com/baeldung/classnotfoundexception/ClassNotFoundExceptionTest.java

@@ -0,0 +1,11 @@
+package com.baeldung.classnotfoundexception;
+
+import org.junit.Test;
+
+public class ClassNotFoundExceptionTest {
+
+    @Test(expected = ClassNotFoundException.class)
+    public void givenNoDriversInClassPath_whenLoadDrivers_thenClassNotFoundException() throws ClassNotFoundException {
+        Class.forName("oracle.jdbc.driver.OracleDriver");
+    }
+}

core-java/src/test/java/com/baeldung/java8/Java8MapAndFlatMap.java

@@ -0,0 +1,52 @@
+package com.baeldung.java8;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertEquals;
+
+public class Java8MapAndFlatMap {
+
+    @Test
+    public void givenStream_whenCalledMap_thenProduceList() {
+        List<String> myList = Stream.of("a", "b")
+                .map(String::toUpperCase)
+                .collect(Collectors.toList());
+        assertEquals(asList("A", "B"), myList);
+    }
+
+    @Test
+    public void givenStream_whenCalledFlatMap_thenProduceFlattenedList() throws Exception {
+        List<List<String>> list = Arrays.asList(Arrays.asList("a"), Arrays.asList("b"));
+        System.out.println(list);
+
+        System.out.println(list
+                .stream().flatMap(Collection::stream)
+                .collect(Collectors.toList()));
+    }
+
+    @Test
+    public void givenOptional_whenCalledMap_thenProduceOptional() {
+        Optional<String> s = Optional.of("test");
+        assertEquals(Optional.of("TEST"), s.map(String::toUpperCase));
+    }
+
+    @Test
+    public void givenOptional_whenCalledFlatMap_thenProduceFlattenedOptional() {
+        assertEquals(Optional.of(Optional.of("STRING")), Optional
+                .of("string")
+                .map(s -> Optional.of("STRING")));
+
+        assertEquals(Optional.of("STRING"), Optional
+                .of("string")
+                .flatMap(s -> Optional.of("STRING")));
+    }
+
+}

core-java/src/test/java/com/baeldung/maths/RoundTest.java

@@ -0,0 +1,71 @@
+package com.baeldung.maths;
+
+import org.apache.commons.math3.util.Precision;
+import org.decimal4j.util.DoubleRounder;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class RoundTest {
+    private double value = 2.03456d;
+    private int places = 2;
+    private double delta = 0.0d;
+    private double expected = 2.03d;
+
+    @Test
+    public void givenDecimalNumber_whenRoundToNDecimalPlaces_thenGetExpectedResult() {   
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertEquals(expected, Round.roundNotPrecise(value, places), delta);
+        Assert.assertEquals(expected, Round.roundAvoid(value, places), delta);
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertEquals(expected, DoubleRounder.round(value, places), delta);
+        
+        places = 3;
+        expected = 2.035d;
+        
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertEquals(expected, Round.roundNotPrecise(value, places), delta);
+        Assert.assertEquals(expected, Round.roundAvoid(value, places), delta);
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertEquals(expected, DoubleRounder.round(value, places), delta);
+        
+        value = 1000.0d;
+        places = 17;
+        expected = 1000.0d;
+        
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertEquals(expected, Round.roundNotPrecise(value, places), delta);
+        Assert.assertNotEquals(expected, Round.roundAvoid(value, places), delta); // Returns: 92.23372036854776 !
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertEquals(expected, DoubleRounder.round(value, places), delta);
+        
+        value = 256.025d;
+        places = 2;
+        expected = 256.03d;
+        
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertNotEquals(expected, Round.roundNotPrecise(value, places), delta); // Returns: 256.02 !
+        Assert.assertNotEquals(expected, Round.roundAvoid(value, places), delta); // Returns: 256.02 !
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertNotEquals(expected, DoubleRounder.round(value, places), delta); // Returns: 256.02 !
+        
+        value = 260.775d; 
+        places = 2;
+        expected = 260.78d;
+        
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertNotEquals(expected, Round.roundNotPrecise(value, places), delta); // Returns: 260.77 !
+        Assert.assertNotEquals(expected, Round.roundAvoid(value, places), delta); // Returns: 260.77 !
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertNotEquals(expected, DoubleRounder.round(value, places), delta); // Returns: 260.77 !
+        
+        value = 90080070060.1d;
+        places = 9;
+        expected = 90080070060.1d;
+        
+        Assert.assertEquals(expected, Round.round(value, places), delta);
+        Assert.assertEquals(expected, Round.roundNotPrecise(value, places), delta);
+        Assert.assertNotEquals(expected, Round.roundAvoid(value, places), delta); // Returns: 9.223372036854776E9 !
+        Assert.assertEquals(expected, Precision.round(value, places), delta);
+        Assert.assertEquals(expected, DoubleRounder.round(value, places), delta);
+    }
+}

core-java/src/test/java/com/baeldung/noclassdeffounderror/NoClassDefFoundErrorTest.java

@@ -0,0 +1,12 @@
+package com.baeldung.noclassdeffounderror;
+
+import org.junit.Test;
+
+public class NoClassDefFoundErrorTest {
+
+    @Test(expected = NoClassDefFoundError.class)
+    public void givenInitErrorInClass_whenloadClass_thenNoClassDefFoundError() {
+        NoClassDefFoundErrorExample sample = new NoClassDefFoundErrorExample();
+        sample.getClassWithInitErrors();
+    }
+}

core-java/src/test/java/com/baeldung/regexp/EscapingCharsTest.java

@@ -0,0 +1,71 @@
+package com.baeldung.regexp;
+
+import static junit.framework.TestCase.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.hamcrest.CoreMatchers.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.junit.Test;
+
+public class EscapingCharsTest {
+    @Test
+    public void givenRegexWithDot_whenMatchingStr_thenMatches() {
+        String strInput = "foof";
+        String strRegex = "foo.";
+        
+        assertEquals(true, strInput.matches(strRegex));
+    }
+    
+    @Test
+    public void givenRegexWithDotEsc_whenMatchingStr_thenNotMatching() {
+        String strInput = "foof";
+        String strRegex = "foo\\.";
+        
+        assertEquals(false, strInput.matches(strRegex));
+    }
+    
+    @Test
+    public void givenRegexWithPipeEscaped_whenSplitStr_thenSplits() {
+        String strInput = "foo|bar|hello|world";
+        String strRegex = "\\Q|\\E";
+        
+        assertEquals(4, strInput.split(strRegex).length);
+    }
+    
+    @Test
+    public void givenRegexWithPipeEscQuoteMeth_whenSplitStr_thenSplits() {
+        String strInput = "foo|bar|hello|world";
+        String strRegex = "|";
+        
+        assertEquals(4,strInput.split(Pattern.quote(strRegex)).length);
+    }
+    
+    @Test
+    public void givenRegexWithDollar_whenReplacing_thenNotReplace() {
+        String strInput = "I gave $50 to my brother."
+                + "He bought candy for $35. Now he has $15 left.";
+        String strRegex = "$";
+        String strReplacement = "£";
+        String output = "I gave £50 to my brother."
+                + "He bought candy for £35. Now he has £15 left.";
+        Pattern p = Pattern.compile(strRegex);
+        Matcher m = p.matcher(strInput);
+        
+        assertThat(output, not(equalTo(m.replaceAll(strReplacement))));
+    }
+    
+    @Test
+    public void givenRegexWithDollarEsc_whenReplacing_thenReplace() {
+        String strInput = "I gave $50 to my brother."
+                + "He bought candy for $35. Now he has $15 left.";
+        String strRegex = "\\$";
+        String strReplacement = "£";
+        String output = "I gave £50 to my brother."
+                + "He bought candy for £35. Now he has £15 left.";
+        Pattern p = Pattern.compile(strRegex);
+        Matcher m = p.matcher(strInput);
+        
+        assertEquals(output,m.replaceAll(strReplacement));
+    }
+}

core-java/src/test/java/com/baeldung/stream/StreamAddUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.stream;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+public class StreamAddUnitTest {
+
+    @Test
+    public void givenStream_whenAppendingObject_thenAppended() {
+        Stream<String> anStream = Stream.of("a", "b", "c", "d", "e");
+
+        Stream<String> newStream = Stream.concat(anStream, Stream.of("A"));
+
+        List<String> resultList = newStream.collect(Collectors.toList());
+        assertEquals(resultList.get(resultList.size() - 1), "A");
+    }
+
+    @Test
+    public void givenStream_whenPrependingObject_thenPrepended() {
+        Stream<Integer> anStream = Stream.of(1, 2, 3, 4, 5);
+
+        Stream<Integer> newStream = Stream.concat(Stream.of(99), anStream);
+
+        assertEquals(newStream.findFirst()
+            .get(), (Integer) 99);
+    }
+
+    @Test
+    public void givenStream_whenInsertingObject_thenInserted() {
+        Stream<Double> anStream = Stream.of(1.1, 2.2, 3.3);
+
+        Stream<Double> newStream = insertInStream(anStream, 9.9, 3);
+
+        List<Double> resultList = newStream.collect(Collectors.toList());
+        assertEquals(resultList.get(3), (Double) 9.9);
+    }
+
+    public <T> Stream<T> insertInStream(Stream<T> stream, T elem, int index) {
+        List<T> result = stream.collect(Collectors.toList());
+        result.add(index, elem);
+        return result.stream();
+    }
+}

core-java/src/test/java/com/baeldung/stream/StreamApiTest.java

@@ -0,0 +1,43 @@
+package com.baeldung.stream;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+public class StreamApiTest {
+    private StreamApi streamApi = new StreamApi();
+
+    @Test
+    public void givenList_whenGetLastElementUsingReduce_thenReturnLastElement() {
+        List<String> valueList = new ArrayList<String>();
+        valueList.add("Joe");
+        valueList.add("John");
+        valueList.add("Sean");
+
+        String last = streamApi.getLastElementUsingReduce(valueList);
+
+        assertEquals("Sean", last);
+    }
+    
+    @Test
+    public void givenInfiniteStream_whenGetInfiniteStreamLastElementUsingReduce_thenReturnLastElement() {
+        Integer last = streamApi.getInfiniteStreamLastElementUsingReduce();
+        assertEquals(new Integer(19), last);
+    }
+    
+    @Test
+    public void givenListAndCount_whenGetLastElementUsingSkip_thenReturnLastElement() {
+        List<String> valueList = new ArrayList<String>();
+        valueList.add("Joe");
+        valueList.add("John");
+        valueList.add("Sean");
+
+        String last = streamApi.getLastElementUsingSkip(valueList);
+
+        assertEquals("Sean", last);
+    }
+
+}

core-java/src/test/java/org/baeldung/java/JavaRandomUnitTest.java

@@ -167,9 +167,11 @@ public class JavaRandomUnitTest {
         final int leftLimit = 97; // letter 'a'
         final int rightLimit = 122; // letter 'z'
         final int targetStringLength = 10;
+        final Random random = new Random();
         final StringBuilder buffer = new StringBuilder(targetStringLength);
+
         for (int i = 0; i < targetStringLength; i++) {
-            final int randomLimitedInt = leftLimit + (int) (new Random().nextFloat() * (rightLimit - leftLimit + 1));
+            final int randomLimitedInt = leftLimit + (int) (random.nextFloat() * (rightLimit - leftLimit + 1));
             buffer.append((char) randomLimitedInt);
         }
         final String generatedString = buffer.toString();

ejb/ejb-session-beans/pom.xml

@@ -0,0 +1,106 @@
+<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>
+  <parent>
+    <groupId>com.baeldung.ejb</groupId>
+    <artifactId>ejb</artifactId>
+    <version>1.0-SNAPSHOT</version>
+  </parent>
+  <artifactId>ejb-session-beans</artifactId>
+  
+  <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <arquillian-bom.version>1.1.12.Final</arquillian-bom.version>
+        <shrinkwrap-resolver-impl-maven.version>2.2.6</shrinkwrap-resolver-impl-maven.version>
+        <arquillian-junit-container.version>1.1.12.Final</arquillian-junit-container.version>
+        <arquillian-glassfish-embedded-3.1.version>1.0.0.Final</arquillian-glassfish-embedded-3.1.version>
+        <junit.version>4.12</junit.version>
+        <javaee-api.version>7.0</javaee-api.version>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>org.jboss.arquillian</groupId>
+                <artifactId>arquillian-bom</artifactId>
+                <version>1.1.13.Final</version>
+                <scope>import</scope>
+                <type>pom</type>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>javax</groupId>
+            <artifactId>javaee-api</artifactId>
+            <version>${javaee-api.version}</version>
+            <scope>provided</scope>
+        </dependency>
+
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+
+
+        <dependency>
+            <groupId>org.jboss.arquillian.junit</groupId>
+            <artifactId>arquillian-junit-container</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies>
+
+    <profiles>
+        <profile>
+            <id>arquillian-glassfish-embedded</id>
+            <activation>
+                <activeByDefault>true</activeByDefault>
+            </activation>
+            <dependencies>
+                <dependency>
+                    <groupId>org.jboss.arquillian.container</groupId>
+                    <artifactId>arquillian-glassfish-embedded-3.1</artifactId>
+                    <version>1.0.0.CR4</version>
+                    <scope>test</scope>
+                </dependency>
+                <dependency>
+                    <groupId>org.glassfish.main.extras</groupId>
+                    <artifactId>glassfish-embedded-all</artifactId>
+                    <version>3.1.2</version>
+                    <scope>test</scope>
+                </dependency>
+            </dependencies>
+        </profile>
+    </profiles>
+
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <artifactId>maven-war-plugin</artifactId>
+                <version>2.4</version>
+                <configuration>
+                    <failOnMissingWebXml>false</failOnMissingWebXml>
+                </configuration>
+            </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.17</version>
+            </plugin>
+        </plugins>
+    </build>
+  
+  
+</project>

ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/EJBClient1.java

@@ -0,0 +1,11 @@
+package com.baeldung.ejb.stateful;
+
+import javax.ejb.EJB;
+
+public class EJBClient1 {
+
+    @EJB
+    public StatefulEJB statefulEJB;
+
+
+}

ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/EJBClient2.java

@@ -0,0 +1,11 @@
+package com.baeldung.ejb.stateful;
+
+import javax.ejb.EJB;
+
+public class EJBClient2 {
+
+    @EJB
+    public StatefulEJB statefulEJB;
+
+
+}

ejb/ejb-session-beans/src/main/java/com/baeldung/ejb/stateful/StatefulEJB.java

@@ -0,0 +1,10 @@
+package com.baeldung.ejb.stateful;
+
+import javax.ejb.Stateful;
+
+@Stateful
+public class StatefulEJB {
+
+    public String name;
+
+}