Merge branch 'master' into master

2017-06-02 00:36:15 +01:00
parent 9d0b9dbed1 d3597a84c7
commit a955425592
202 changed files with 6085 additions and 1225 deletions
@@ -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

@@ -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);
+    }
+}
@@ -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)
+
@@ -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();
+        }
+    }
+}
@@ -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;
+        }
+    }
+}
@@ -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());
+	}
+}
@@ -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);
+		}
+	}
+}
@@ -33,7 +33,7 @@ public class Round {
    
    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();
@@ -0,0 +1,5 @@
+package com.baeldung.noclassdeffounderror;
+
+public class ClassWithInitErrors {
+    static int data = 1 / 0;
+}
@@ -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;
+    }
+}
@@ -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);
+    }
+
+}
@@ -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);
@@ -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);
+    }
+
+}
@@ -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");
+    }
+}
@@ -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();
+    }
+}
@@ -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));
+    }
+}
@@ -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();
+    }
+}
@@ -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);
+    }
+
+}
@@ -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();
@@ -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>
@@ -0,0 +1,11 @@
+package com.baeldung.ejb.stateful;
+
+import javax.ejb.EJB;
+
+public class EJBClient1 {
+
+    @EJB
+    public StatefulEJB statefulEJB;
+
+
+}
@@ -0,0 +1,11 @@
+package com.baeldung.ejb.stateful;
+
+import javax.ejb.EJB;
+
+public class EJBClient2 {
+
+    @EJB
+    public StatefulEJB statefulEJB;
+
+
+}
@@ -0,0 +1,10 @@
+package com.baeldung.ejb.stateful;
+
+import javax.ejb.Stateful;
+
+@Stateful
+public class StatefulEJB {
+
+    public String name;
+
+}
@@ -0,0 +1,10 @@
+package com.baeldung.ejb.stateless;
+
+import javax.ejb.EJB;
+
+public class EJBClient1 {
+
+    @EJB
+    public StatelessEJB statelessEJB;
+
+}
@@ -0,0 +1,11 @@
+package com.baeldung.ejb.stateless;
+
+import javax.ejb.EJB;
+
+public class EJBClient2 {
+
+    @EJB
+    public  StatelessEJB statelessEJB;
+
+
+}
@@ -0,0 +1,11 @@
+package com.baeldung.ejb.stateless;
+
+import javax.ejb.Stateless;
+
+
+@Stateless
+public class StatelessEJB {
+
+    public String name;
+
+}
@@ -0,0 +1,51 @@
+package com.baeldung.ejb.test.stateful;
+
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import com.baeldung.ejb.stateful.EJBClient1;
+import com.baeldung.ejb.stateful.EJBClient2;
+import com.baeldung.ejb.stateful.StatefulEJB;
+
+import javax.inject.Inject;
+
+
+@RunWith(Arquillian.class)
+public class StatefulEJBTest {
+
+    @Inject
+    private EJBClient1 ejbClient1;
+
+    @Inject
+    private EJBClient2 ejbClient2;
+
+    @Test
+    public void givenOneStatefulBean_whenTwoClientsSetValueOnBean_thenClientStateIsMaintained() {
+
+        // act
+        ejbClient1.statefulEJB.name = "Client 1";
+        ejbClient2.statefulEJB.name = "Client 2";
+
+        // assert
+        Assert.assertNotEquals(ejbClient1.statefulEJB.name, ejbClient2.statefulEJB.name);
+        Assert.assertEquals("Client 1", ejbClient1.statefulEJB.name);
+        Assert.assertEquals("Client 2", ejbClient2.statefulEJB.name);
+
+    }
+
+    @Deployment
+    public static JavaArchive createDeployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+                .addClass(StatefulEJB.class)
+                .addClass(EJBClient1.class)
+                .addClass(EJBClient2.class)
+                .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+}
@@ -0,0 +1,62 @@
+package com.baeldung.ejb.test.stateless;
+
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.EmptyAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import com.baeldung.ejb.stateless.EJBClient1;
+import com.baeldung.ejb.stateless.EJBClient2;
+import com.baeldung.ejb.stateless.StatelessEJB;
+
+import javax.inject.Inject;
+
+
+@RunWith(Arquillian.class)
+public class StatelessEJBTest {
+
+    @Inject
+    private EJBClient1 ejbClient1;
+
+    @Inject
+    private EJBClient2 ejbClient2;
+
+    @Test
+    public void givenOneStatelessBean_whenStateIsSetInOneBean_secondBeanShouldHaveSameState() {
+
+        // act
+        ejbClient1.statelessEJB.name = "Client 1";
+
+        // assert
+        Assert.assertEquals("Client 1", ejbClient1.statelessEJB.name);
+        Assert.assertEquals("Client 1", ejbClient2.statelessEJB.name);
+
+    }
+
+
+    @Test
+    public void givenOneStatelessBean_whenStateIsSetInBothBeans_secondBeanShouldHaveSecondBeanState() {
+
+        // act
+        ejbClient1.statelessEJB.name = "Client 1";
+        ejbClient2.statelessEJB.name = "Client 2";
+
+        // assert
+        Assert.assertEquals("Client 2", ejbClient2.statelessEJB.name);
+
+    }
+
+    @Deployment
+    public static JavaArchive createDeployment() {
+        return ShrinkWrap.create(JavaArchive.class)
+                .addClass(StatelessEJB.class)
+                .addClass(EJBClient1.class)
+                .addClass(EJBClient2.class)
+                .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
+    }
+
+}
@@ -40,7 +40,12 @@
                <version>1.0-SNAPSHOT</version>
                <type>ejb</type>
            </dependency>
-
+			 <dependency>
+                <groupId>com.baeldung.ejb</groupId>
+                <artifactId>ejb-session-beans</artifactId>
+                <version>1.0-SNAPSHOT</version>
+                <type>ejb</type>
+            </dependency>
            <dependency>
                <groupId>javax</groupId>
                <artifactId>javaee-api</artifactId>
@@ -75,5 +80,7 @@
    <modules>
        <module>ejb-remote</module>
        <module>ejb-client</module>
+        <module>ejb-session-beans</module>
+        <module>ejb-session-beans-client</module>
    </modules>
 </project>
@@ -1,2 +1,3 @@
 ### Relevant articles:
 - [New Stream, Comparator and Collector Functionality in Guava 21](http://www.baeldung.com/guava-21-new)
+- [New in Guava 21 common.util.concurrent](http://www.baeldung.com/guava-21-util-concurrent)
--- a/Show More
+++ b/Show More