Merge branch 'master' of https://github.com/ahmedtawila/tutorials

algorithms/README.md

@@ -6,3 +6,5 @@
 - [Validating Input With Finite Automata in Java](http://www.baeldung.com/finite-automata-java)
 - [Introduction to Jenetics Library](http://www.baeldung.com/jenetics)
 - [Check If a Number Is Prime in Java](http://www.baeldung.com/java-prime-numbers)
+- [Example of Hill Climbing Algorithm](http://www.baeldung.com/java-hill-climbing-algorithm)
+- [Monte Carlo Tree Search for Tic-Tac-Toe Game](http://www.baeldung.com/java-monte-carlo-tree-search)

algorithms/src/main/java/com/baeldung/algorithms/minimax/MiniMax.java

@@ -18,12 +18,12 @@ public class MiniMax {
         constructTree(root);
     }
 
-    private void constructTree(Node node) {
-        List<Integer> listofPossibleHeaps = GameOfBones.getPossibleStates(node.getNoOfBones());
-        boolean isMaxPlayer = !node.isMaxPlayer();
+    private void constructTree(Node parentNode) {
+        List<Integer> listofPossibleHeaps = GameOfBones.getPossibleStates(parentNode.getNoOfBones());
+        boolean isChildMaxPlayer = !parentNode.isMaxPlayer();
         listofPossibleHeaps.forEach(n -> {
-            Node newNode = new Node(n, isMaxPlayer);
-            node.addChild(newNode);
+            Node newNode = new Node(n, isChildMaxPlayer);
+            parentNode.addChild(newNode);
             if (newNode.getNoOfBones() > 0) {
                 constructTree(newNode);
             }

asciidoctor/pom.xml

@@ -35,7 +35,12 @@
                 <configuration>
                     <sourceDirectory>src/docs/asciidoc</sourceDirectory>
                     <outputDirectory>target/docs/asciidoc</outputDirectory>
+                    <attributes>
+                        <pdf-stylesdir>${project.basedir}/src/themes</pdf-stylesdir>
+                        <pdf-style>custom</pdf-style>
+                    </attributes>
                     <backend>pdf</backend>
+                    <doctype>book</doctype>
                 </configuration>
             </plugin>
         </plugins>

asciidoctor/src/docs/asciidoc/test.adoc

@@ -1,3 +1,13 @@
-== Introduction Section
+:icons: font
 
-Hi. I'm a simple test to see if this Maven build is working. If you see me in a nice PDF, then it means everything is [red]#working#.
+
+= Generating book with AsciiDoctorj
+Baeldung
+
+[abstract]
+This is the actual content.
+
+== First Section
+
+This is first section of the book where you can include some nice icons like icon:comment[].
+You can also create http://www.baeldung.com[links]

asciidoctor/src/themes/custom-theme.yml

@@ -0,0 +1,29 @@
+title_page:
+  align: left
+
+page:
+  layout: portrait
+  margin: [0.75in, 1in, 0.75in, 1in]
+  size: A4
+base:
+  font_color: #333333
+  line_height_length: 17
+  line_height: $base_line_height_length / $base_font_size
+link:
+  font_color: #009900
+
+header:
+  height: 0.5in
+  line_height: 1
+  recto_content:
+    center: '{document-title}'
+  verso_content:
+    center: '{document-title}'
+
+footer:
+  height: 0.5in
+  line_height: 1
+  recto_content:
+    right: '{chapter-title} | *{page-number}*'
+  verso_content:
+    left: '*{page-number}* | {chapter-title}'

aws/pom.xml

@@ -18,9 +18,41 @@
         <aws-lambda-java-events.version>1.3.0</aws-lambda-java-events.version>
         <aws-lambda-java-core.version>1.1.0</aws-lambda-java-core.version>
         <gson.version>2.8.0</gson.version>
+        <aws-java-sdk.version>1.11.154</aws-java-sdk.version>
+        <junit.version>4.12</junit.version>
+        <mockito-core.version>2.8.9</mockito-core.version>
+        <assertj-core.version>3.8.0</assertj-core.version>
     </properties>
 
     <dependencies>
+    
+        <dependency>
+            <groupId>com.amazonaws</groupId>
+            <artifactId>aws-java-sdk</artifactId>
+            <version>${aws-java-sdk.version}</version>
+        </dependency>
+        
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>${mockito-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    
         <dependency>
             <groupId>com.amazonaws</groupId>
             <artifactId>aws-lambda-java-core</artifactId>

aws/src/main/java/com/baeldung/s3/AWSS3Service.java

@@ -0,0 +1,87 @@
+package com.baeldung.s3;
+
+import java.io.File;
+import java.util.List;
+
+import com.amazonaws.services.s3.AmazonS3;
+import com.amazonaws.services.s3.AmazonS3Client;
+import com.amazonaws.services.s3.model.Bucket;
+import com.amazonaws.services.s3.model.CopyObjectResult;
+import com.amazonaws.services.s3.model.DeleteObjectsRequest;
+import com.amazonaws.services.s3.model.DeleteObjectsResult;
+import com.amazonaws.services.s3.model.ObjectListing;
+import com.amazonaws.services.s3.model.PutObjectResult;
+import com.amazonaws.services.s3.model.S3Object;
+
+public class AWSS3Service {
+    private final AmazonS3 s3client;
+
+    public AWSS3Service() { 
+        this(new AmazonS3Client() {
+        }); 
+    } 
+    
+    public AWSS3Service(AmazonS3 s3client) {
+        this.s3client = s3client;
+    }
+    
+    //is bucket exist?
+    public boolean doesBucketExist(String bucketName) { 
+        return s3client.doesBucketExist(bucketName); 
+    } 
+    
+    //create a bucket
+    public Bucket createBucket(String bucketName) { 
+        return s3client.createBucket(bucketName); 
+    } 
+
+    //list all buckets
+    public List<Bucket> listBuckets() { 
+        return s3client.listBuckets(); 
+    }
+
+    //delete a bucket
+    public void deleteBucket(String bucketName) { 
+        s3client.deleteBucket(bucketName); 
+    }  
+    
+    //uploading object
+    public PutObjectResult putObject(String bucketName, String key, File file) {
+        return s3client.putObject(bucketName, key, file);
+    }
+    
+    //listing objects
+    public ObjectListing listObjects(String bucketName) {
+        return s3client.listObjects(bucketName);
+    }
+    
+    //get an object
+    public S3Object getObject(String bucketName, String objectKey) {
+        return s3client.getObject(bucketName, objectKey);
+    } 
+    
+    //copying an object
+    public CopyObjectResult copyObject(
+      String sourceBucketName,
+      String sourceKey,
+      String destinationBucketName,
+      String destinationKey
+    ) {
+        return s3client.copyObject(
+          sourceBucketName, 
+          sourceKey, 
+          destinationBucketName, 
+          destinationKey
+        );
+    }
+    
+    //deleting an object
+    public void deleteObject(String bucketName, String objectKey) {
+        s3client.deleteObject(bucketName, objectKey);
+    }
+    
+    //deleting multiple Objects
+    public DeleteObjectsResult deleteObjects(DeleteObjectsRequest delObjReq) {
+        return s3client.deleteObjects(delObjReq);
+    }
+}

aws/src/main/java/com/baeldung/s3/S3Application.java

@@ -0,0 +1,101 @@
+package com.baeldung.s3;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.apache.commons.io.FileUtils;
+
+import com.amazonaws.auth.AWSCredentials;
+import com.amazonaws.auth.AWSStaticCredentialsProvider;
+import com.amazonaws.auth.BasicAWSCredentials;
+import com.amazonaws.regions.Regions;
+import com.amazonaws.services.s3.AmazonS3;
+import com.amazonaws.services.s3.AmazonS3ClientBuilder;
+import com.amazonaws.services.s3.model.Bucket;
+import com.amazonaws.services.s3.model.DeleteObjectsRequest;
+import com.amazonaws.services.s3.model.ObjectListing;
+import com.amazonaws.services.s3.model.S3Object;
+import com.amazonaws.services.s3.model.S3ObjectInputStream;
+import com.amazonaws.services.s3.model.S3ObjectSummary;
+
+public class S3Application {
+
+    private static final AWSCredentials credentials;
+    private static String bucketName;  
+
+    static {
+        //put your accesskey and secretkey here
+        credentials = new BasicAWSCredentials(
+          "<AWS accesskey>", 
+          "<AWS secretkey>"
+        );
+    }
+    
+    public static void main(String[] args) throws IOException {
+        //set-up the client
+        AmazonS3 s3client = AmazonS3ClientBuilder
+          .standard()
+          .withCredentials(new AWSStaticCredentialsProvider(credentials))
+          .withRegion(Regions.US_EAST_2)
+          .build();
+        
+        AWSS3Service awsService = new AWSS3Service(s3client);
+
+        bucketName = "baeldung-bucket";
+
+        //creating a bucket
+        if(awsService.doesBucketExist(bucketName)) {
+            System.out.println("Bucket name is not available."
+              + " Try again with a different Bucket name.");
+            return;
+        }
+        awsService.createBucket(bucketName);
+        
+        //list all the buckets
+        for(Bucket s : awsService.listBuckets() ) {
+            System.out.println(s.getName());
+        }
+        
+        //deleting bucket
+        awsService.deleteBucket("baeldung-bucket-test2");
+        
+        //uploading object
+        awsService.putObject(
+          bucketName, 
+          "Document/hello.txt",
+          new File("/Users/user/Document/hello.txt")
+        );
+
+        //listing objects
+        ObjectListing objectListing = awsService.listObjects(bucketName);
+        for(S3ObjectSummary os : objectListing.getObjectSummaries()) {
+            System.out.println(os.getKey());
+        }
+
+        //downloading an object
+        S3Object s3object = awsService.getObject(bucketName, "Document/hello.txt");
+        S3ObjectInputStream inputStream = s3object.getObjectContent();
+        FileUtils.copyInputStreamToFile(inputStream, new File("/Users/user/Desktop/hello.txt"));
+        
+        //copying an object
+        awsService.copyObject(
+          "baeldung-bucket", 
+          "picture/pic.png", 
+          "baeldung-bucket2", 
+          "Document/picture.png"
+        );
+        
+        //deleting an object
+        awsService.deleteObject(bucketName, "Document/hello.txt");
+
+        //deleting multiple objects
+        String objkeyArr[] = {
+          "Document/hello2.txt", 
+          "Document/picture.png"
+        };
+        
+        DeleteObjectsRequest delObjReq = new DeleteObjectsRequest("baeldung-bucket")
+          .withKeys(objkeyArr);
+        awsService.deleteObjects(delObjReq);
+    }
+}

aws/src/test/java/com/baeldung/s3/AWSS3ServiceIntegrationTest.java

@@ -0,0 +1,113 @@
+package com.baeldung.s3;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.File;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.amazonaws.services.s3.AmazonS3;
+import com.amazonaws.services.s3.model.CopyObjectResult;
+import com.amazonaws.services.s3.model.DeleteObjectsRequest;
+import com.amazonaws.services.s3.model.DeleteObjectsResult;
+import com.amazonaws.services.s3.model.PutObjectResult; 
+
+public class AWSS3ServiceIntegrationTest {
+
+    private static final String BUCKET_NAME = "bucket_name"; 
+    private static final String KEY_NAME = "key_name"; 
+    private static final String BUCKET_NAME2 = "bucket_name2"; 
+    private static final String KEY_NAME2 = "key_name2"; 
+ 
+    private AmazonS3 s3; 
+    private AWSS3Service service; 
+ 
+    @Before 
+    public void setUp() { 
+        s3 = mock(AmazonS3.class); 
+        service = new AWSS3Service(s3); 
+    } 
+ 
+    @Test 
+    public void whenInitializingAWSS3Service_thenNotNull() { 
+        assertThat(new AWSS3Service()).isNotNull(); 
+    } 
+    
+    @Test 
+    public void whenVerifyingIfS3BucketExist_thenCorrect() { 
+        service.doesBucketExist(BUCKET_NAME); 
+        verify(s3).doesBucketExist(BUCKET_NAME); 
+    } 
+ 
+    @Test 
+    public void whenVerifyingCreationOfS3Bucket_thenCorrect() { 
+        service.createBucket(BUCKET_NAME); 
+        verify(s3).createBucket(BUCKET_NAME); 
+    } 
+ 
+    @Test 
+    public void whenVerifyingListBuckets_thenCorrect() { 
+        service.listBuckets(); 
+        verify(s3).listBuckets(); 
+    } 
+
+    @Test 
+    public void whenDeletingBucket_thenCorrect() { 
+        service.deleteBucket(BUCKET_NAME); 
+        verify(s3).deleteBucket(BUCKET_NAME); 
+    } 
+    
+    @Test 
+    public void whenVerifyingPutObject_thenCorrect() { 
+        File file = mock(File.class); 
+        PutObjectResult result = mock(PutObjectResult.class); 
+        when(s3.putObject(anyString(), anyString(), (File) any())).thenReturn(result); 
+ 
+        assertThat(service.putObject(BUCKET_NAME, KEY_NAME, file)).isEqualTo(result); 
+        verify(s3).putObject(BUCKET_NAME, KEY_NAME, file); 
+    }
+    
+    @Test 
+    public void whenVerifyingListObjects_thenCorrect() { 
+        service.listObjects(BUCKET_NAME); 
+        verify(s3).listObjects(BUCKET_NAME); 
+    } 
+    
+    @Test 
+    public void whenVerifyingGetObject_thenCorrect() { 
+        service.getObject(BUCKET_NAME, KEY_NAME); 
+        verify(s3).getObject(BUCKET_NAME, KEY_NAME); 
+    } 
+    
+    @Test 
+    public void whenVerifyingCopyObject_thenCorrect() { 
+        CopyObjectResult result = mock(CopyObjectResult.class); 
+        when(s3.copyObject(anyString(), anyString(), anyString(), anyString())).thenReturn(result); 
+ 
+        assertThat(service.copyObject(BUCKET_NAME, KEY_NAME, BUCKET_NAME2, KEY_NAME2)).isEqualTo(result); 
+        verify(s3).copyObject(BUCKET_NAME, KEY_NAME, BUCKET_NAME2, KEY_NAME2);
+    } 
+    
+    @Test 
+    public void whenVerifyingDeleteObject_thenCorrect() { 
+        service.deleteObject(BUCKET_NAME, KEY_NAME); 
+        verify(s3).deleteObject(BUCKET_NAME, KEY_NAME); 
+    }
+    
+    @Test 
+    public void whenVerifyingDeleteObjects_thenCorrect() { 
+        DeleteObjectsRequest request = mock(DeleteObjectsRequest.class);
+        DeleteObjectsResult result = mock(DeleteObjectsResult.class);
+        when(s3.deleteObjects((DeleteObjectsRequest)any())).thenReturn(result); 
+        
+        assertThat(service.deleteObjects(request)).isEqualTo(result);
+        verify(s3).deleteObjects(request); 
+    }
+    
+}

camel-api/src/main/java/com/baeldung/camel/Application.java

@@ -13,14 +13,13 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.web.servlet.ServletRegistrationBean;
-import org.springframework.boot.web.support.SpringBootServletInitializer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.stereotype.Component;
 
 @SpringBootApplication
 @ComponentScan(basePackages="com.baeldung.camel")
-public class Application extends SpringBootServletInitializer {
+public class Application{
 
     @Value("${server.port}")
     String serverPort;
@@ -62,10 +61,12 @@ public class Application extends SpringBootServletInitializer {
                 .bindingMode(RestBindingMode.json)
                 .dataFormatProperty("prettyPrint", "true");
 /** 
-The Rest DSL supports automatic binding json/xml contents to/from POJOs using Camels Data Format.
-By default the binding mode is off, meaning there is no automatic binding happening for incoming and outgoing messages.
-You may want to use binding if you develop POJOs that maps to your REST services request and response types. 
-This allows you, as a developer, to work with the POJOs in Java code.
+The Rest DSL supports automatic binding json/xml contents to/from 
+POJOs using Camels Data Format.
+By default the binding mode is off, meaning there is no automatic 
+binding happening for incoming and outgoing messages.
+You may want to use binding if you develop POJOs that maps to 
+your REST services request and response types. 
 */         
             
             rest("/api/").description("Teste REST Service")

core-java-9/README.md

@@ -13,3 +13,6 @@
 - [Java 9 Process API Improvements](http://www.baeldung.com/java-9-process-api)
 - [Introduction to Java 9 StackWalking API](http://www.baeldung.com/java-9-stackwalking-api)
 - [Introduction to Project Jigsaw](http://www.baeldung.com/project-jigsaw-java-modularity)
+- [Java 9 Optional API Additions](http://www.baeldung.com/java-9-optional)
+- [Java 9 Reactive Streams](http://www.baeldung.com/java-9-reactive-streams)
+- [How to Get All Dates Between Two Dates?](http://www.baeldung.com/java-between-dates)

core-java/README.md

@@ -113,6 +113,16 @@
 - [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)
+- [The Dining Philosophers Problem in Java](http://www.baeldung.com/java-dining-philoshophers)
+- [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)
+- [Converting String to Stream of chars](http://www.baeldung.com/java-string-to-stream)
+- [Changing the Order in a Sum Operation Can Produce Different Results?](http://www.baeldung.com/java-floating-point-sum-order)
+- [How to Get a Name of a Method Being Executed?](http://www.baeldung.com/java-name-of-executing-method)
+- [Iterate over a Map in Java](http://www.baeldung.com/java-iterate-map)
+- [CyclicBarrier in Java](http://www.baeldung.com/java-cyclic-barrier)
 - [Dynamic Proxies in Java](http://www.baeldung.com/java-dynamic-proxies)
 - [How to Copy an Array in Java](http://www.baeldung.com/java-array-copy)
 - [Introduction to JDBC](http://www.baeldung.com/java-jdbc)

core-java/hashcode/pom.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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.hashcode</groupId>
+    <artifactId>hashcode</artifactId>
+    <version>1.0</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>1.7.25</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>1.7.25</version>
+        </dependency>
+    </dependencies>
+</project>

core-java/hashcode/src/main/java/com/baeldung/application/Application.java

@@ -0,0 +1,23 @@
+package com.baeldung.application;
+
+import com.baeldung.entities.User;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Application {
+
+    public static void main(String[] args) {
+        Map<User, User> users = new HashMap<>();
+        User user1 = new User(1L, "John", "[email protected]");
+        User user2 = new User(2L, "Jennifer", "[email protected]");
+        User user3 = new User(3L, "Mary", "[email protected]");
+
+        users.put(user1, user1);
+        users.put(user2, user2);
+        users.put(user3, user3);
+
+        if (users.containsKey(user1)) {
+            System.out.print("User found in the collection");
+        }
+    }
+}

core-java/hashcode/src/main/java/com/baeldung/entities/User.java

@@ -0,0 +1,38 @@
+package com.baeldung.entities;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class User {
+
+    private final Logger logger = LoggerFactory.getLogger(User.class);
+    private long id;
+    private String name;
+    private String email;
+
+    public User(long id, String name, String email) {
+        this.id = id;
+        this.name = name;
+        this.email = email;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null) return false;
+        if (this.getClass() != o.getClass()) return false;
+        User user = (User) o;
+        return id != user.id && (!name.equals(user.name) && !email.equals(user.email));
+    }
+    	
+    @Override
+    public int hashCode() {
+        int hash = 7;
+        hash = 31 * hash + (int) id;
+        hash = 31 * hash + (name == null ? 0 : name.hashCode());
+        hash = 31 * hash + (email == null ? 0 : email.hashCode());
+        logger.info("hashCode() method called - Computed hash: " + hash);
+        return hash;
+    }
+    // getters and setters here
+}

core-java/hashcode/src/test/java/com/baeldung/application/ApplicationTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.application;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import static org.junit.Assert.assertEquals;
+
+public class ApplicationTest {
+
+    private ByteArrayOutputStream outContent;
+
+    @Before
+    public void setUpPrintStreamInstance() throws Exception {
+        this.outContent = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(outContent));
+    }
+
+    @After
+    public void tearDownByteArrayOutputStream() throws Exception {
+        outContent = null;
+    }
+
+    @Test
+    public void main_NoInputState_TextPrintedToConsole() throws Exception {
+        Application.main(new String[]{});
+        assertEquals("User found in the collection", outContent.toString());
+    }
+}

core-java/hashcode/src/test/java/com/baeldung/entities/UserTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.entities;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class UserTest {
+
+    private User user;
+    private User comparisonUser;
+
+    @Before
+    public void setUpUserInstances() {
+        this.user = new User(1L, "test", "[email protected]");
+        this.comparisonUser = this.user;
+    }
+
+    @After
+    public void tearDownUserInstances() {
+        user = null;
+        comparisonUser = null;
+    }
+
+    @Test
+    public void equals_EqualUserInstance_TrueAssertion(){
+        Assert.assertTrue(user.equals(comparisonUser));
+    }
+
+    @Test
+    public void hashCode_UserHash_TrueAssertion() {
+        Assert.assertEquals(1792276941, user.hashCode());
+    }
+}

core-java/pom.xml

@@ -382,7 +382,7 @@
         </profile>
     </profiles>
 
-    <properties>
+    <properties>    	
         <!-- marshalling -->
         <jackson.version>2.8.5</jackson.version>
 
@@ -408,7 +408,7 @@
         <!-- testing -->
         <org.hamcrest.version>1.3</org.hamcrest.version>
         <junit.version>4.12</junit.version>
-        <mockito.version>1.10.19</mockito.version>
+        <mockito.version>2.8.9</mockito.version>
         <assertj.version>3.6.1</assertj.version>
         <avaitility.version>1.7.0</avaitility.version>
 

core-java/src/main/java/com/baeldung/concurrent/Scheduledexecutorservice/ScheduledExecutorServiceDemo.java

@@ -0,0 +1,34 @@
+package com.baeldung.concurrent.Scheduledexecutorservice;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+public class ScheduledExecutorServiceDemo {
+
+	public void execute() {
+		ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
+
+		ScheduledFuture<?> scheduledFuture = executorService.schedule(() -> {
+			// Task
+		}, 1, TimeUnit.SECONDS);
+
+		executorService.scheduleAtFixedRate(() -> {
+			// Task
+		}, 1, 10, TimeUnit.SECONDS);
+
+		executorService.scheduleWithFixedDelay(() -> {
+			// Task
+		}, 1, 10, TimeUnit.SECONDS);
+
+		Future<String> future = executorService.schedule(() -> {
+			// Task
+			return "Hellow world";
+		}, 1, TimeUnit.SECONDS);
+
+		executorService.shutdown();
+	}
+
+}

core-java/src/main/java/com/baeldung/concurrent/atomic/SafeCounterWithLock.java

@@ -0,0 +1,13 @@
+package com.baeldung.concurrent.atomic;
+
+public class SafeCounterWithLock {
+    private volatile int counter;
+    
+    public int getValue() {
+        return counter;
+    }
+    
+    public synchronized void increment() {
+        counter++;
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/atomic/SafeCounterWithoutLock.java

@@ -0,0 +1,21 @@
+package com.baeldung.concurrent.atomic;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class SafeCounterWithoutLock {
+    private final AtomicInteger counter = new AtomicInteger(0);
+    
+    public int getValue() {
+        return counter.get();
+    }
+    
+    public void increment() {
+        while(true) {
+            int existingValue = getValue();
+            int newValue = existingValue + 1;
+            if(counter.compareAndSet(existingValue, newValue)) {
+                return;
+            }
+        }
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/atomic/UnsafeCounter.java

@@ -0,0 +1,13 @@
+package com.baeldung.concurrent.atomic;
+
+public class UnsafeCounter {
+    int counter;
+    
+    public int getValue() {
+        return counter;
+    }
+    
+    public void increment() {
+        counter++;
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/cyclicbarrier/CyclicBarrierExample.java

@@ -0,0 +1,24 @@
+package com.baeldung.concurrent.cyclicbarrier;
+
+import java.util.concurrent.CyclicBarrier;
+
+public class CyclicBarrierExample {
+
+    public void start() {
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> {
+            // Task
+            System.out.println("All previous tasks are completed");
+        });
+
+        Thread t1 = new Thread(new Task(cyclicBarrier), "T1");
+        Thread t2 = new Thread(new Task(cyclicBarrier), "T2");
+        Thread t3 = new Thread(new Task(cyclicBarrier), "T3");
+
+        if (!cyclicBarrier.isBroken()) {
+            t1.start();
+            t2.start();
+            t3.start();
+        }
+    }
+}
+

core-java/src/main/java/com/baeldung/concurrent/cyclicbarrier/Task.java

@@ -0,0 +1,24 @@
+package com.baeldung.concurrent.cyclicbarrier;
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+
+public class Task implements Runnable {
+
+    private CyclicBarrier barrier;
+
+    public Task(CyclicBarrier barrier) {
+        this.barrier = barrier;
+    }
+
+    @Override
+    public void run() {
+        try {
+            System.out.println("Thread : " + Thread.currentThread().getName() + " is waiting");
+            barrier.await();
+            System.out.println("Thread : " + Thread.currentThread().getName() + " is released");
+        } catch (InterruptedException | BrokenBarrierException e) {
+            e.printStackTrace();
+        }
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/executor/ExecutorDemo.java

@@ -0,0 +1,14 @@
+package com.baeldung.concurrent.executor;
+
+import java.util.concurrent.Executor;
+
+public class ExecutorDemo {
+
+	public void execute() {
+		Executor executor = new Invoker();
+		executor.execute(()->{
+			// task to be performed
+		});
+	}
+
+}

core-java/src/main/java/com/baeldung/concurrent/executor/Invoker.java

@@ -0,0 +1,12 @@
+package com.baeldung.concurrent.executor;
+
+import java.util.concurrent.Executor;
+
+public class Invoker implements Executor {
+
+	@Override
+	public void execute(Runnable r) {
+		r.run();
+	}
+
+}

core-java/src/main/java/com/baeldung/concurrent/executorservice/ExecutorServiceDemo.java

@@ -0,0 +1,27 @@
+package com.baeldung.concurrent.executorservice;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+public class ExecutorServiceDemo {
+
+	ExecutorService executor = Executors.newFixedThreadPool(10);
+
+	public void execute() {
+
+		executor.submit(() -> {
+			new Task();
+		});
+
+		executor.shutdown();
+		executor.shutdownNow();
+		try {
+			executor.awaitTermination(20l, TimeUnit.NANOSECONDS);
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

core-java/src/main/java/com/baeldung/concurrent/executorservice/Task.java

@@ -0,0 +1,10 @@
+package com.baeldung.concurrent.executorservice;
+
+public class Task implements Runnable {
+
+	@Override
+	public void run() {
+		// task details
+	}
+
+}

core-java/src/main/java/com/baeldung/concurrent/future/FutureDemo.java

@@ -0,0 +1,44 @@
+package com.baeldung.concurrent.future;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class FutureDemo {
+
+	public String invoke() {
+
+		String str = null;
+
+		ExecutorService executorService = Executors.newFixedThreadPool(10);
+
+		Future<String> future = executorService.submit(() -> {
+			// Task
+			Thread.sleep(10000l);
+			return "Hellow world";
+		});
+
+		future.cancel(false);
+
+		try {
+			future.get(20, TimeUnit.SECONDS);
+		} catch (InterruptedException | ExecutionException | TimeoutException e1) {
+			e1.printStackTrace();
+		}
+
+		if (future.isDone() && !future.isCancelled()) {
+			try {
+				str = future.get();
+			} catch (InterruptedException | ExecutionException e) {
+				e.printStackTrace();
+			}
+		}
+
+		return str;
+
+	}
+
+}

core-java/src/main/java/com/baeldung/concurrent/semaphore/SemaPhoreDemo.java

@@ -0,0 +1,22 @@
+package com.baeldung.concurrent.semaphore;
+
+import java.util.concurrent.Semaphore;
+
+public class SemaPhoreDemo {
+
+	static Semaphore semaphore = new Semaphore(10);
+	
+	public void execute() throws InterruptedException {
+
+		System.out.println("Available permit : " + semaphore.availablePermits());
+		System.out.println("Number of threads waiting to acquire: " + semaphore.getQueueLength());
+
+		if (semaphore.tryAcquire()) {
+			semaphore.acquire();
+			// perform some critical operations
+			semaphore.release();
+		}
+
+	}
+
+}