Merge branch 'master' of https://github.com/vicmosin/tutorials into vicmosin-master

.gitignore

@@ -27,3 +27,4 @@ target/
 
 spring-openid/src/main/resources/application.properties
 .recommenders/
+/spring-hibernate4/nbproject/

JGit/pom.xml

@@ -0,0 +1,63 @@
+<?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</groupId>
+    <artifactId>JGitSnippets</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <url>http://maven.apache.org</url>
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+    <repositories>
+    <repository>
+      <id>jgit-repository</id>
+      <url>https://repo.eclipse.org/content/groups/releases/</url>
+    </repository>
+  </repositories>
+
+  <!-- Core Library -->
+  <dependencies>
+    <dependency>
+      <groupId>org.eclipse.jgit</groupId>
+      <artifactId>org.eclipse.jgit</artifactId>
+      <version>4.5.0.201609210915-r</version>
+    </dependency>
+    <dependency>
+      <groupId>org.eclipse.jgit</groupId>
+      <artifactId>org.eclipse.jgit.archive</artifactId>
+      <version>4.5.0.201609210915-r</version>
+    </dependency>
+	<dependency>
+		<groupId>commons-io</groupId>
+		<artifactId>commons-io</artifactId>
+		<version>2.5</version>
+	</dependency>
+	<dependency>
+		<groupId>org.slf4j</groupId>
+		<artifactId>slf4j-simple</artifactId>
+		<version>1.7.21</version>
+	</dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.12</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.2</version>
+        <configuration>
+          <source>1.7</source>
+          <target>1.7</target>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>

JGit/src/main/java/com/baeldung/jgit/CreateNewRepository.java

@@ -0,0 +1,30 @@
+package com.baeldung.jgit;
+
+import java.io.File;
+import java.io.IOException;
+import org.apache.commons.io.FileUtils;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+
+/**
+ * Simple snippet which shows how to create a new repository
+ *
+ * 
+ */
+public class CreateNewRepository {
+
+    public static void main(String[] args) throws IOException, IllegalStateException, GitAPIException {
+        // prepare a new folder
+        File localPath = File.createTempFile("TestGitRepository", "");
+        if(!localPath.delete()) {
+            throw new IOException("Could not delete temporary file " + localPath);
+        }
+
+        // create the directory
+        try (Git git = Git.init().setDirectory(localPath).call()) {
+            System.out.println("Having repository: " + git.getRepository().getDirectory());
+        }
+
+        FileUtils.deleteDirectory(localPath);
+    }
+}

JGit/src/main/java/com/baeldung/jgit/OpenRepository.java

@@ -0,0 +1,65 @@
+package com.baeldung.jgit;
+
+import com.baeldung.jgit.helper.Helper;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * Simple snippet which shows how to open an existing repository
+ *
+ * 
+ */
+public class OpenRepository {
+
+    public static void main(String[] args) throws IOException, GitAPIException {
+        // first create a test-repository, the return is including the .get directory here!
+        File repoDir = createSampleGitRepo();
+
+        // now open the resulting repository with a FileRepositoryBuilder
+        FileRepositoryBuilder builder = new FileRepositoryBuilder();
+        try (Repository repository = builder.setGitDir(repoDir)
+                .readEnvironment() // scan environment GIT_* variables
+                .findGitDir() // scan up the file system tree
+                .build()) {
+            System.out.println("Having repository: " + repository.getDirectory());
+
+            // the Ref holds an ObjectId for any type of object (tree, commit, blob, tree)
+            Ref head = repository.exactRef("refs/heads/master");
+            System.out.println("Ref of refs/heads/master: " + head);
+        }
+    }
+
+    private static File createSampleGitRepo() throws IOException, GitAPIException {
+        try (Repository repository = Helper.createNewRepository()) {
+            System.out.println("Temporary repository at " + repository.getDirectory());
+
+            // create the file
+            File myfile = new File(repository.getDirectory().getParent(), "testfile");
+            if(!myfile.createNewFile()) {
+                throw new IOException("Could not create file " + myfile);
+            }
+
+            // run the add-call
+            try (Git git = new Git(repository)) {
+                git.add()
+                        .addFilepattern("testfile")
+                        .call();
+
+
+                // and then commit the changes
+                git.commit()
+                        .setMessage("Added testfile")
+                        .call();
+            }
+
+            System.out.println("Added file " + myfile + " to repository at " + repository.getDirectory());
+
+            return repository.getDirectory();
+        }
+    }
+}

JGit/src/main/java/com/baeldung/jgit/helper/Helper.java

@@ -0,0 +1,33 @@
+
+package com.baeldung.jgit.helper;
+
+import java.io.File;
+import java.io.IOException;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
+
+public class Helper {
+    
+    public static Repository openJGitRepository() throws IOException {
+        FileRepositoryBuilder builder = new FileRepositoryBuilder();
+        return builder
+                .readEnvironment() // scan environment GIT_* variables
+                .findGitDir() // scan up the file system tree
+                .build();
+    }
+    
+     public static Repository createNewRepository() throws IOException {
+        // prepare a new folder
+        File localPath = File.createTempFile("TestGitRepository", "");
+        if(!localPath.delete()) {
+            throw new IOException("Could not delete temporary file " + localPath);
+        }
+
+        // create the directory
+        Repository repository = FileRepositoryBuilder.create(new File(localPath, ".git"));
+        repository.create();
+
+        return repository;
+    }
+    
+}

JGit/src/main/java/com/baeldung/jgit/porcelain/AddFile.java

@@ -0,0 +1,36 @@
+package com.baeldung.jgit.porcelain;
+
+import java.io.File;
+import java.io.IOException;
+import com.baeldung.jgit.helper.Helper;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.Repository;
+
+/**
+ * Simple snippet which shows how to add a file to the index
+ *
+ * 
+ */
+public class AddFile {
+
+    public static void main(String[] args) throws IOException, GitAPIException {
+        // prepare a new test-repository
+        try (Repository repository = Helper.createNewRepository()) {
+            try (Git git = new Git(repository)) {
+                // create the file
+                File myfile = new File(repository.getDirectory().getParent(), "testfile");
+                if(!myfile.createNewFile()) {
+                    throw new IOException("Could not create file " + myfile);
+                }
+
+                // run the add-call
+                git.add()
+                        .addFilepattern("testfile")
+                        .call();
+
+                System.out.println("Added file " + myfile + " to repository at " + repository.getDirectory());
+            }
+        }
+    }
+}

JGit/src/main/java/com/baeldung/jgit/porcelain/CommitAll.java

@@ -0,0 +1,51 @@
+package com.baeldung.jgit.porcelain;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import com.baeldung.jgit.helper.Helper;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.Repository;
+
+/**
+ * Simple snippet which shows how to commit all files
+ *
+ * 
+ */
+public class CommitAll {
+
+    public static void main(String[] args) throws IOException, GitAPIException {
+        // prepare a new test-repository
+        try (Repository repository = Helper.createNewRepository()) {
+            try (Git git = new Git(repository)) {
+                // create the file
+                File myfile = new File(repository.getDirectory().getParent(), "testfile");
+                if(!myfile.createNewFile()) {
+                    throw new IOException("Could not create file " + myfile);
+                }
+
+                // Stage all files in the repo including new files
+                git.add().addFilepattern(".").call();
+
+                // and then commit the changes.
+                git.commit()
+                        .setMessage("Commit all changes including additions")
+                        .call();
+
+                try(PrintWriter writer = new PrintWriter(myfile)) {
+                    writer.append("Hello, world!");
+                }
+
+                // Stage all changed files, omitting new files, and commit with one command
+                git.commit()
+                        .setAll(true)
+                        .setMessage("Commit changes to all files")
+                        .call();
+
+
+                System.out.println("Committed all changes to repository at " + repository.getDirectory());
+            }
+        }
+    }
+}

JGit/src/main/java/com/baeldung/jgit/porcelain/CreateAndDeleteTag.java

@@ -0,0 +1,56 @@
+package com.baeldung.jgit.porcelain;
+
+import java.io.IOException;
+import com.baeldung.jgit.helper.Helper;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.eclipse.jgit.revwalk.RevWalk;
+
+/**
+ * Simple snippet which shows how to create a tag
+ *
+ * 
+ */
+public class CreateAndDeleteTag {
+
+    public static void main(String[] args) throws IOException, GitAPIException {
+        // prepare test-repository
+        try (Repository repository = Helper.openJGitRepository()) {
+            try (Git git = new Git(repository)) {
+                // remove the tag before creating it
+                git.tagDelete().setTags("tag_for_testing").call();
+
+                // set it on the current HEAD
+                Ref tag = git.tag().setName("tag_for_testing").call();
+                System.out.println("Created/moved tag " + tag + " to repository at " + repository.getDirectory());
+
+                // remove the tag again
+                git.tagDelete().setTags("tag_for_testing").call();
+
+                // read some other commit and set the tag on it
+                ObjectId id = repository.resolve("HEAD^");
+                try (RevWalk walk = new RevWalk(repository)) {
+                    RevCommit commit = walk.parseCommit(id);
+                    tag = git.tag().setObjectId(commit).setName("tag_for_testing").call();
+                    System.out.println("Created/moved tag " + tag + " to repository at " + repository.getDirectory());
+
+                    // remove the tag again
+                    git.tagDelete().setTags("tag_for_testing").call();
+
+                    // create an annotated tag
+                    tag = git.tag().setName("tag_for_testing").setAnnotated(true).call();
+                    System.out.println("Created/moved tag " + tag + " to repository at " + repository.getDirectory());
+
+                    // remove the tag again
+                    git.tagDelete().setTags("tag_for_testing").call();
+
+                    walk.dispose();
+                }
+            }
+        }
+    }
+}

JGit/src/main/java/com/baeldung/jgit/porcelain/Log.java

@@ -0,0 +1,74 @@
+package com.baeldung.jgit.porcelain;
+
+import java.io.IOException;
+import com.baeldung.jgit.helper.Helper;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevCommit;
+
+/**
+ * Simple snippet which shows how to get the commit-ids for a file to provide log information.
+ *
+ * 
+ */
+public class Log {
+
+    @SuppressWarnings("unused")
+    public static void main(String[] args) throws IOException, GitAPIException {
+        try (Repository repository = Helper.openJGitRepository()) {
+            try (Git git = new Git(repository)) {
+                Iterable<RevCommit> logs = git.log()
+                        .call();
+                int count = 0;
+                for (RevCommit rev : logs) {
+                    //System.out.println("Commit: " + rev /* + ", name: " + rev.getName() + ", id: " + rev.getId().getName() */);
+                    count++;
+                }
+                System.out.println("Had " + count + " commits overall on current branch");
+
+                logs = git.log()
+                        .add(repository.resolve("remotes/origin/testbranch"))
+                        .call();
+                count = 0;
+                for (RevCommit rev : logs) {
+                    System.out.println("Commit: " + rev /* + ", name: " + rev.getName() + ", id: " + rev.getId().getName() */);
+                    count++;
+                }
+                System.out.println("Had " + count + " commits overall on test-branch");
+
+                logs = git.log()
+                        .all()
+                        .call();
+                count = 0;
+                for (RevCommit rev : logs) {
+                    //System.out.println("Commit: " + rev /* + ", name: " + rev.getName() + ", id: " + rev.getId().getName() */);
+                    count++;
+                }
+                System.out.println("Had " + count + " commits overall in repository");
+
+                logs = git.log()
+                        // for all log.all()
+                        .addPath("README.md")
+                        .call();
+                count = 0;
+                for (RevCommit rev : logs) {
+                    //System.out.println("Commit: " + rev /* + ", name: " + rev.getName() + ", id: " + rev.getId().getName() */);
+                    count++;
+                }
+                System.out.println("Had " + count + " commits on README.md");
+
+                logs = git.log()
+                        // for all log.all()
+                        .addPath("pom.xml")
+                        .call();
+                count = 0;
+                for (RevCommit rev : logs) {
+                    //System.out.println("Commit: " + rev /* + ", name: " + rev.getName() + ", id: " + rev.getId().getName() */);
+                    count++;
+                }
+                System.out.println("Had " + count + " commits on pom.xml");
+            }
+        }
+    }
+}

JGit/src/test/java/com/baeldung/jgit/JGitBugTest.java

@@ -0,0 +1,31 @@
+import com.baeldung.jgit.helper.Helper;
+import org.eclipse.jgit.lib.ObjectLoader;
+import org.eclipse.jgit.lib.ObjectReader;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevWalk;
+import org.junit.Test;
+import java.io.IOException;
+import static org.junit.Assert.assertNotNull;
+
+/**
+ * Tests which show issues with JGit that we reported upstream.
+ */
+public class JGitBugTest {
+    @Test
+    public void testRevWalkDisposeClosesReader() throws IOException {
+        try (Repository repo = Helper.openJGitRepository()) {
+            try (ObjectReader reader = repo.newObjectReader()) {
+                try (RevWalk walk = new RevWalk(reader)) {
+                    walk.dispose();
+
+                    Ref head = repo.exactRef("refs/heads/master");
+                    System.out.println("Found head: " + head);
+
+                    ObjectLoader loader = reader.open(head.getObjectId());
+                    assertNotNull(loader);
+                }
+            }
+        }
+    }
+}

JGit/src/test/java/com/baeldung/jgit/porcelain/PorcelainTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.jgit.porcelain;
+
+import org.junit.Test;
+
+public class PorcelainTest {
+    @Test
+    public void runSamples() throws Exception {
+        // simply call all the samples to see any severe problems with the samples
+        AddFile.main(null);
+        
+        CommitAll.main(null);
+        
+        CreateAndDeleteTag.main(null);
+         
+        Log.main(null);    
+    }
+}

algorithms/src/main/java/com/baeldung/algorithms/dijkstra/Dijkstra.java

@@ -18,9 +18,7 @@ public class Dijkstra {
         while (unsettledNodes.size() != 0) {
             Node currentNode = getLowestDistanceNode(unsettledNodes);
             unsettledNodes.remove(currentNode);
-            for (Entry<Node, Integer> adjacencyPair : currentNode
-              .getAdjacentNodes()
-              .entrySet()) {
+            for (Entry<Node, Integer> adjacencyPair : currentNode.getAdjacentNodes().entrySet()) {
                 Node adjacentNode = adjacencyPair.getKey();
                 Integer edgeWeigh = adjacencyPair.getValue();
 

algorithms/src/test/java/algorithms/DijkstraAlgorithmTest.java

@@ -55,29 +55,19 @@ public class DijkstraAlgorithmTest {
         for (Node node : graph.getNodes()) {
             switch (node.getName()) {
             case "B":
-                assertTrue(node
-                  .getShortestPath()
-                  .equals(shortestPathForNodeB));
+                assertTrue(node.getShortestPath().equals(shortestPathForNodeB));
                 break;
             case "C":
-                assertTrue(node
-                  .getShortestPath()
-                  .equals(shortestPathForNodeC));
+                assertTrue(node.getShortestPath().equals(shortestPathForNodeC));
                 break;
             case "D":
-                assertTrue(node
-                  .getShortestPath()
-                  .equals(shortestPathForNodeD));
+                assertTrue(node.getShortestPath().equals(shortestPathForNodeD));
                 break;
             case "E":
-                assertTrue(node
-                  .getShortestPath()
-                  .equals(shortestPathForNodeE));
+                assertTrue(node.getShortestPath().equals(shortestPathForNodeE));
                 break;
             case "F":
-                assertTrue(node
-                  .getShortestPath()
-                  .equals(shortestPathForNodeF));
+                assertTrue(node.getShortestPath().equals(shortestPathForNodeF));
                 break;
             }
         }

annotations/annotation-processing/src/main/java/com/baeldung/annotation/processor/BuilderProcessor.java

@@ -27,17 +27,12 @@ public class BuilderProcessor extends AbstractProcessor {
 
             Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(annotation);
 
-            Map<Boolean, List<Element>> annotatedMethods = annotatedElements.stream()
-                    .collect(Collectors.partitioningBy(element ->
-                            ((ExecutableType) element.asType()).getParameterTypes().size() == 1
-                                    && element.getSimpleName().toString().startsWith("set")));
+            Map<Boolean, List<Element>> annotatedMethods = annotatedElements.stream().collect(Collectors.partitioningBy(element -> ((ExecutableType) element.asType()).getParameterTypes().size() == 1 && element.getSimpleName().toString().startsWith("set")));
 
             List<Element> setters = annotatedMethods.get(true);
             List<Element> otherMethods = annotatedMethods.get(false);
 
-            otherMethods.forEach(element ->
-                    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
-                            "@BuilderProperty must be applied to a setXxx method with a single argument", element));
+            otherMethods.forEach(element -> processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "@BuilderProperty must be applied to a setXxx method with a single argument", element));
 
             if (setters.isEmpty()) {
                 continue;
@@ -45,11 +40,7 @@ public class BuilderProcessor extends AbstractProcessor {
 
             String className = ((TypeElement) setters.get(0).getEnclosingElement()).getQualifiedName().toString();
 
-            Map<String, String> setterMap = setters.stream().collect(Collectors.toMap(
-                    setter -> setter.getSimpleName().toString(),
-                    setter -> ((ExecutableType) setter.asType())
-                            .getParameterTypes().get(0).toString()
-            ));
+            Map<String, String> setterMap = setters.stream().collect(Collectors.toMap(setter -> setter.getSimpleName().toString(), setter -> ((ExecutableType) setter.asType()).getParameterTypes().get(0).toString()));
 
             try {
                 writeBuilderFile(className, setterMap);

annotations/annotation-user/src/test/java/com/baeldung/annotation/PersonBuilderTest.java

@@ -9,10 +9,7 @@ public class PersonBuilderTest {
     @Test
     public void whenBuildPersonWithBuilder_thenObjectHasPropertyValues() {
 
-        Person person = new PersonBuilder()
-                .setAge(25)
-                .setName("John")
-                .build();
+        Person person = new PersonBuilder().setAge(25).setName("John").build();
 
         assertEquals(25, person.getAge());
         assertEquals("John", person.getName());

annotations/pom.xml

@@ -1,6 +1,5 @@
 <?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"
+<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">
     <parent>
         <artifactId>parent-modules</artifactId>

apache-fop/pom.xml

@@ -1,4 +1,5 @@
-<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">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.baeldung</groupId>
     <artifactId>apache-fop</artifactId>

apache-thrift/generated/com/baeldung/thrift/impl/CrossPlatformResource.java

@@ -0,0 +1,579 @@
+/**
+ * Autogenerated by Thrift Compiler (0.10.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package com.baeldung.thrift.impl;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.10.0)", date = "2017-02-01")
+public class CrossPlatformResource implements org.apache.thrift.TBase<CrossPlatformResource, CrossPlatformResource._Fields>, java.io.Serializable, Cloneable, Comparable<CrossPlatformResource> {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("CrossPlatformResource");
+
+  private static final org.apache.thrift.protocol.TField ID_FIELD_DESC = new org.apache.thrift.protocol.TField("id", org.apache.thrift.protocol.TType.I32, (short)1);
+  private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)2);
+  private static final org.apache.thrift.protocol.TField SALUTATION_FIELD_DESC = new org.apache.thrift.protocol.TField("salutation", org.apache.thrift.protocol.TType.STRING, (short)3);
+
+  private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new CrossPlatformResourceStandardSchemeFactory();
+  private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new CrossPlatformResourceTupleSchemeFactory();
+
+  public int id; // required
+  public java.lang.String name; // required
+  public java.lang.String salutation; // optional
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    ID((short)1, "id"),
+    NAME((short)2, "name"),
+    SALUTATION((short)3, "salutation");
+
+    private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+    static {
+      for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // ID
+          return ID;
+        case 2: // NAME
+          return NAME;
+        case 3: // SALUTATION
+          return SALUTATION;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(java.lang.String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final java.lang.String _fieldName;
+
+    _Fields(short thriftId, java.lang.String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public java.lang.String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  private static final int __ID_ISSET_ID = 0;
+  private byte __isset_bitfield = 0;
+  private static final _Fields optionals[] = {_Fields.SALUTATION};
+  public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.ID, new org.apache.thrift.meta_data.FieldMetaData("id", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.SALUTATION, new org.apache.thrift.meta_data.FieldMetaData("salutation", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CrossPlatformResource.class, metaDataMap);
+  }
+
+  public CrossPlatformResource() {
+  }
+
+  public CrossPlatformResource(
+    int id,
+    java.lang.String name)
+  {
+    this();
+    this.id = id;
+    setIdIsSet(true);
+    this.name = name;
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public CrossPlatformResource(CrossPlatformResource other) {
+    __isset_bitfield = other.__isset_bitfield;
+    this.id = other.id;
+    if (other.isSetName()) {
+      this.name = other.name;
+    }
+    if (other.isSetSalutation()) {
+      this.salutation = other.salutation;
+    }
+  }
+
+  public CrossPlatformResource deepCopy() {
+    return new CrossPlatformResource(this);
+  }
+
+  @Override
+  public void clear() {
+    setIdIsSet(false);
+    this.id = 0;
+    this.name = null;
+    this.salutation = null;
+  }
+
+  public int getId() {
+    return this.id;
+  }
+
+  public CrossPlatformResource setId(int id) {
+    this.id = id;
+    setIdIsSet(true);
+    return this;
+  }
+
+  public void unsetId() {
+    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __ID_ISSET_ID);
+  }
+
+  /** Returns true if field id is set (has been assigned a value) and false otherwise */
+  public boolean isSetId() {
+    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __ID_ISSET_ID);
+  }
+
+  public void setIdIsSet(boolean value) {
+    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __ID_ISSET_ID, value);
+  }
+
+  public java.lang.String getName() {
+    return this.name;
+  }
+
+  public CrossPlatformResource setName(java.lang.String name) {
+    this.name = name;
+    return this;
+  }
+
+  public void unsetName() {
+    this.name = null;
+  }
+
+  /** Returns true if field name is set (has been assigned a value) and false otherwise */
+  public boolean isSetName() {
+    return this.name != null;
+  }
+
+  public void setNameIsSet(boolean value) {
+    if (!value) {
+      this.name = null;
+    }
+  }
+
+  public java.lang.String getSalutation() {
+    return this.salutation;
+  }
+
+  public CrossPlatformResource setSalutation(java.lang.String salutation) {
+    this.salutation = salutation;
+    return this;
+  }
+
+  public void unsetSalutation() {
+    this.salutation = null;
+  }
+
+  /** Returns true if field salutation is set (has been assigned a value) and false otherwise */
+  public boolean isSetSalutation() {
+    return this.salutation != null;
+  }
+
+  public void setSalutationIsSet(boolean value) {
+    if (!value) {
+      this.salutation = null;
+    }
+  }
+
+  public void setFieldValue(_Fields field, java.lang.Object value) {
+    switch (field) {
+    case ID:
+      if (value == null) {
+        unsetId();
+      } else {
+        setId((java.lang.Integer)value);
+      }
+      break;
+
+    case NAME:
+      if (value == null) {
+        unsetName();
+      } else {
+        setName((java.lang.String)value);
+      }
+      break;
+
+    case SALUTATION:
+      if (value == null) {
+        unsetSalutation();
+      } else {
+        setSalutation((java.lang.String)value);
+      }
+      break;
+
+    }
+  }
+
+  public java.lang.Object getFieldValue(_Fields field) {
+    switch (field) {
+    case ID:
+      return getId();
+
+    case NAME:
+      return getName();
+
+    case SALUTATION:
+      return getSalutation();
+
+    }
+    throw new java.lang.IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new java.lang.IllegalArgumentException();
+    }
+
+    switch (field) {
+    case ID:
+      return isSetId();
+    case NAME:
+      return isSetName();
+    case SALUTATION:
+      return isSetSalutation();
+    }
+    throw new java.lang.IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(java.lang.Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof CrossPlatformResource)
+      return this.equals((CrossPlatformResource)that);
+    return false;
+  }
+
+  public boolean equals(CrossPlatformResource that) {
+    if (that == null)
+      return false;
+    if (this == that)
+      return true;
+
+    boolean this_present_id = true;
+    boolean that_present_id = true;
+    if (this_present_id || that_present_id) {
+      if (!(this_present_id && that_present_id))
+        return false;
+      if (this.id != that.id)
+        return false;
+    }
+
+    boolean this_present_name = true && this.isSetName();
+    boolean that_present_name = true && that.isSetName();
+    if (this_present_name || that_present_name) {
+      if (!(this_present_name && that_present_name))
+        return false;
+      if (!this.name.equals(that.name))
+        return false;
+    }
+
+    boolean this_present_salutation = true && this.isSetSalutation();
+    boolean that_present_salutation = true && that.isSetSalutation();
+    if (this_present_salutation || that_present_salutation) {
+      if (!(this_present_salutation && that_present_salutation))
+        return false;
+      if (!this.salutation.equals(that.salutation))
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    int hashCode = 1;
+
+    hashCode = hashCode * 8191 + id;
+
+    hashCode = hashCode * 8191 + ((isSetName()) ? 131071 : 524287);
+    if (isSetName())
+      hashCode = hashCode * 8191 + name.hashCode();
+
+    hashCode = hashCode * 8191 + ((isSetSalutation()) ? 131071 : 524287);
+    if (isSetSalutation())
+      hashCode = hashCode * 8191 + salutation.hashCode();
+
+    return hashCode;
+  }
+
+  @Override
+  public int compareTo(CrossPlatformResource other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+
+    lastComparison = java.lang.Boolean.valueOf(isSetId()).compareTo(other.isSetId());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetId()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.id, other.id);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = java.lang.Boolean.valueOf(isSetName()).compareTo(other.isSetName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = java.lang.Boolean.valueOf(isSetSalutation()).compareTo(other.isSetSalutation());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetSalutation()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.salutation, other.salutation);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    scheme(iprot).read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    scheme(oprot).write(oprot, this);
+  }
+
+  @Override
+  public java.lang.String toString() {
+    java.lang.StringBuilder sb = new java.lang.StringBuilder("CrossPlatformResource(");
+    boolean first = true;
+
+    sb.append("id:");
+    sb.append(this.id);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("name:");
+    if (this.name == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.name);
+    }
+    first = false;
+    if (isSetSalutation()) {
+      if (!first) sb.append(", ");
+      sb.append("salutation:");
+      if (this.salutation == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.salutation);
+      }
+      first = false;
+    }
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    // check for sub-struct validity
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+    try {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bitfield = 0;
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class CrossPlatformResourceStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+    public CrossPlatformResourceStandardScheme getScheme() {
+      return new CrossPlatformResourceStandardScheme();
+    }
+  }
+
+  private static class CrossPlatformResourceStandardScheme extends org.apache.thrift.scheme.StandardScheme<CrossPlatformResource> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, CrossPlatformResource struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // ID
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.id = iprot.readI32();
+              struct.setIdIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // NAME
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.name = iprot.readString();
+              struct.setNameIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 3: // SALUTATION
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.salutation = iprot.readString();
+              struct.setSalutationIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+
+      // check for required fields of primitive type, which can't be checked in the validate method
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, CrossPlatformResource struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(ID_FIELD_DESC);
+      oprot.writeI32(struct.id);
+      oprot.writeFieldEnd();
+      if (struct.name != null) {
+        oprot.writeFieldBegin(NAME_FIELD_DESC);
+        oprot.writeString(struct.name);
+        oprot.writeFieldEnd();
+      }
+      if (struct.salutation != null) {
+        if (struct.isSetSalutation()) {
+          oprot.writeFieldBegin(SALUTATION_FIELD_DESC);
+          oprot.writeString(struct.salutation);
+          oprot.writeFieldEnd();
+        }
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class CrossPlatformResourceTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+    public CrossPlatformResourceTupleScheme getScheme() {
+      return new CrossPlatformResourceTupleScheme();
+    }
+  }
+
+  private static class CrossPlatformResourceTupleScheme extends org.apache.thrift.scheme.TupleScheme<CrossPlatformResource> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, CrossPlatformResource struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+      java.util.BitSet optionals = new java.util.BitSet();
+      if (struct.isSetId()) {
+        optionals.set(0);
+      }
+      if (struct.isSetName()) {
+        optionals.set(1);
+      }
+      if (struct.isSetSalutation()) {
+        optionals.set(2);
+      }
+      oprot.writeBitSet(optionals, 3);
+      if (struct.isSetId()) {
+        oprot.writeI32(struct.id);
+      }
+      if (struct.isSetName()) {
+        oprot.writeString(struct.name);
+      }
+      if (struct.isSetSalutation()) {
+        oprot.writeString(struct.salutation);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, CrossPlatformResource struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+      java.util.BitSet incoming = iprot.readBitSet(3);
+      if (incoming.get(0)) {
+        struct.id = iprot.readI32();
+        struct.setIdIsSet(true);
+      }
+      if (incoming.get(1)) {
+        struct.name = iprot.readString();
+        struct.setNameIsSet(true);
+      }
+      if (incoming.get(2)) {
+        struct.salutation = iprot.readString();
+        struct.setSalutationIsSet(true);
+      }
+    }
+  }
+
+  private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+    return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+  }
+}
+

apache-thrift/generated/com/baeldung/thrift/impl/InvalidOperationException.java

@@ -0,0 +1,472 @@
+/**
+ * Autogenerated by Thrift Compiler (0.10.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package com.baeldung.thrift.impl;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
+@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.10.0)", date = "2017-02-01")
+public class InvalidOperationException extends org.apache.thrift.TException implements org.apache.thrift.TBase<InvalidOperationException, InvalidOperationException._Fields>, java.io.Serializable, Cloneable, Comparable<InvalidOperationException> {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("InvalidOperationException");
+
+  private static final org.apache.thrift.protocol.TField CODE_FIELD_DESC = new org.apache.thrift.protocol.TField("code", org.apache.thrift.protocol.TType.I32, (short)1);
+  private static final org.apache.thrift.protocol.TField DESCRIPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("description", org.apache.thrift.protocol.TType.STRING, (short)2);
+
+  private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new InvalidOperationExceptionStandardSchemeFactory();
+  private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new InvalidOperationExceptionTupleSchemeFactory();
+
+  public int code; // required
+  public java.lang.String description; // required
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    CODE((short)1, "code"),
+    DESCRIPTION((short)2, "description");
+
+    private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();
+
+    static {
+      for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // CODE
+          return CODE;
+        case 2: // DESCRIPTION
+          return DESCRIPTION;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(java.lang.String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final java.lang.String _fieldName;
+
+    _Fields(short thriftId, java.lang.String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public java.lang.String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  private static final int __CODE_ISSET_ID = 0;
+  private byte __isset_bitfield = 0;
+  public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.CODE, new org.apache.thrift.meta_data.FieldMetaData("code", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.DESCRIPTION, new org.apache.thrift.meta_data.FieldMetaData("description", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(InvalidOperationException.class, metaDataMap);
+  }
+
+  public InvalidOperationException() {
+  }
+
+  public InvalidOperationException(
+    int code,
+    java.lang.String description)
+  {
+    this();
+    this.code = code;
+    setCodeIsSet(true);
+    this.description = description;
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public InvalidOperationException(InvalidOperationException other) {
+    __isset_bitfield = other.__isset_bitfield;
+    this.code = other.code;
+    if (other.isSetDescription()) {
+      this.description = other.description;
+    }
+  }
+
+  public InvalidOperationException deepCopy() {
+    return new InvalidOperationException(this);
+  }
+
+  @Override
+  public void clear() {
+    setCodeIsSet(false);
+    this.code = 0;
+    this.description = null;
+  }
+
+  public int getCode() {
+    return this.code;
+  }
+
+  public InvalidOperationException setCode(int code) {
+    this.code = code;
+    setCodeIsSet(true);
+    return this;
+  }
+
+  public void unsetCode() {
+    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CODE_ISSET_ID);
+  }
+
+  /** Returns true if field code is set (has been assigned a value) and false otherwise */
+  public boolean isSetCode() {
+    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CODE_ISSET_ID);
+  }
+
+  public void setCodeIsSet(boolean value) {
+    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CODE_ISSET_ID, value);
+  }
+
+  public java.lang.String getDescription() {
+    return this.description;
+  }
+
+  public InvalidOperationException setDescription(java.lang.String description) {
+    this.description = description;
+    return this;
+  }
+
+  public void unsetDescription() {
+    this.description = null;
+  }
+
+  /** Returns true if field description is set (has been assigned a value) and false otherwise */
+  public boolean isSetDescription() {
+    return this.description != null;
+  }
+
+  public void setDescriptionIsSet(boolean value) {
+    if (!value) {
+      this.description = null;
+    }
+  }
+
+  public void setFieldValue(_Fields field, java.lang.Object value) {
+    switch (field) {
+    case CODE:
+      if (value == null) {
+        unsetCode();
+      } else {
+        setCode((java.lang.Integer)value);
+      }
+      break;
+
+    case DESCRIPTION:
+      if (value == null) {
+        unsetDescription();
+      } else {
+        setDescription((java.lang.String)value);
+      }
+      break;
+
+    }
+  }
+
+  public java.lang.Object getFieldValue(_Fields field) {
+    switch (field) {
+    case CODE:
+      return getCode();
+
+    case DESCRIPTION:
+      return getDescription();
+
+    }
+    throw new java.lang.IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new java.lang.IllegalArgumentException();
+    }
+
+    switch (field) {
+    case CODE:
+      return isSetCode();
+    case DESCRIPTION:
+      return isSetDescription();
+    }
+    throw new java.lang.IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(java.lang.Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof InvalidOperationException)
+      return this.equals((InvalidOperationException)that);
+    return false;
+  }
+
+  public boolean equals(InvalidOperationException that) {
+    if (that == null)
+      return false;
+    if (this == that)
+      return true;
+
+    boolean this_present_code = true;
+    boolean that_present_code = true;
+    if (this_present_code || that_present_code) {
+      if (!(this_present_code && that_present_code))
+        return false;
+      if (this.code != that.code)
+        return false;
+    }
+
+    boolean this_present_description = true && this.isSetDescription();
+    boolean that_present_description = true && that.isSetDescription();
+    if (this_present_description || that_present_description) {
+      if (!(this_present_description && that_present_description))
+        return false;
+      if (!this.description.equals(that.description))
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    int hashCode = 1;
+
+    hashCode = hashCode * 8191 + code;
+
+    hashCode = hashCode * 8191 + ((isSetDescription()) ? 131071 : 524287);
+    if (isSetDescription())
+      hashCode = hashCode * 8191 + description.hashCode();
+
+    return hashCode;
+  }
+
+  @Override
+  public int compareTo(InvalidOperationException other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+
+    lastComparison = java.lang.Boolean.valueOf(isSetCode()).compareTo(other.isSetCode());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetCode()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.code, other.code);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = java.lang.Boolean.valueOf(isSetDescription()).compareTo(other.isSetDescription());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetDescription()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.description, other.description);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    scheme(iprot).read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    scheme(oprot).write(oprot, this);
+  }
+
+  @Override
+  public java.lang.String toString() {
+    java.lang.StringBuilder sb = new java.lang.StringBuilder("InvalidOperationException(");
+    boolean first = true;
+
+    sb.append("code:");
+    sb.append(this.code);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("description:");
+    if (this.description == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.description);
+    }
+    first = false;
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    // check for sub-struct validity
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
+    try {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bitfield = 0;
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class InvalidOperationExceptionStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+    public InvalidOperationExceptionStandardScheme getScheme() {
+      return new InvalidOperationExceptionStandardScheme();
+    }
+  }
+
+  private static class InvalidOperationExceptionStandardScheme extends org.apache.thrift.scheme.StandardScheme<InvalidOperationException> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, InvalidOperationException struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // CODE
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.code = iprot.readI32();
+              struct.setCodeIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // DESCRIPTION
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.description = iprot.readString();
+              struct.setDescriptionIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+
+      // check for required fields of primitive type, which can't be checked in the validate method
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, InvalidOperationException struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(CODE_FIELD_DESC);
+      oprot.writeI32(struct.code);
+      oprot.writeFieldEnd();
+      if (struct.description != null) {
+        oprot.writeFieldBegin(DESCRIPTION_FIELD_DESC);
+        oprot.writeString(struct.description);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class InvalidOperationExceptionTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
+    public InvalidOperationExceptionTupleScheme getScheme() {
+      return new InvalidOperationExceptionTupleScheme();
+    }
+  }
+
+  private static class InvalidOperationExceptionTupleScheme extends org.apache.thrift.scheme.TupleScheme<InvalidOperationException> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, InvalidOperationException struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+      java.util.BitSet optionals = new java.util.BitSet();
+      if (struct.isSetCode()) {
+        optionals.set(0);
+      }
+      if (struct.isSetDescription()) {
+        optionals.set(1);
+      }
+      oprot.writeBitSet(optionals, 2);
+      if (struct.isSetCode()) {
+        oprot.writeI32(struct.code);
+      }
+      if (struct.isSetDescription()) {
+        oprot.writeString(struct.description);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, InvalidOperationException struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
+      java.util.BitSet incoming = iprot.readBitSet(2);
+      if (incoming.get(0)) {
+        struct.code = iprot.readI32();
+        struct.setCodeIsSet(true);
+      }
+      if (incoming.get(1)) {
+        struct.description = iprot.readString();
+        struct.setDescriptionIsSet(true);
+      }
+    }
+  }
+
+  private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
+    return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
+  }
+}
+

apache-thrift/pom.xml

@@ -0,0 +1,55 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
+    <artifactId>apache-thrift</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <packaging>pom</packaging>
+
+    <properties>
+        <java.versin>1.8</java.versin>
+        <junit.version>4.12</junit.version>
+        <maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
+        <thrift.version>0.10.0</thrift.version>
+        <maven-thrift.version>0.1.11</maven-thrift.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.thrift</groupId>
+            <artifactId>libthrift</artifactId>
+            <version>${thrift.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>1.7.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <defaultGoal>install</defaultGoal>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-compiler-plugin</artifactId>
+                    <version>${maven-compiler-plugin.version}</version>
+                    <configuration>
+                        <source>1.8</source>
+                        <target>1.8</target>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+</project>

apache-thrift/src/main/java/com/baeldung/thrift/Application.java

@@ -0,0 +1,9 @@
+package com.baeldung.thrift;
+
+public class Application {
+
+    public static void main(String[] args) {
+        CrossPlatformServiceServer server = new CrossPlatformServiceServer();
+        server.start();
+    }
+}

apache-thrift/src/main/java/com/baeldung/thrift/CrossPlatformServiceClient.java

@@ -0,0 +1,41 @@
+package com.baeldung.thrift;
+
+import com.baeldung.thrift.impl.CrossPlatformService;
+
+import org.apache.thrift.TException;
+import org.apache.thrift.protocol.TBinaryProtocol;
+import org.apache.thrift.protocol.TProtocol;
+import org.apache.thrift.transport.TSocket;
+import org.apache.thrift.transport.TTransport;
+import org.apache.thrift.transport.TTransportException;
+
+public class CrossPlatformServiceClient {
+
+    public boolean ping() {
+        try {
+            TTransport transport;
+
+            transport = new TSocket("localhost", 9090);
+            transport.open();
+
+            TProtocol protocol = new TBinaryProtocol(transport);
+            CrossPlatformService.Client client = new CrossPlatformService.Client(protocol);
+
+            System.out.print("Calling remote method...");
+
+            boolean result = client.ping();
+
+            System.out.println("done.");
+
+            transport.close();
+
+            return result;
+        } catch (TTransportException e) {
+            e.printStackTrace();
+        } catch (TException x) {
+            x.printStackTrace();
+        }
+
+        return false;
+    }
+}

apache-thrift/src/main/java/com/baeldung/thrift/CrossPlatformServiceImpl.java

@@ -0,0 +1,35 @@
+package com.baeldung.thrift;
+
+import com.baeldung.thrift.impl.CrossPlatformResource;
+import com.baeldung.thrift.impl.CrossPlatformService;
+import com.baeldung.thrift.impl.InvalidOperationException;
+
+import org.apache.thrift.TException;
+
+import java.util.Collections;
+import java.util.List;
+
+public class CrossPlatformServiceImpl implements CrossPlatformService.Iface {
+
+    @Override
+    public CrossPlatformResource get(final int id) throws InvalidOperationException, TException {
+        // add some action
+        return new CrossPlatformResource();
+    }
+
+    @Override
+    public void save(final CrossPlatformResource resource) throws InvalidOperationException, TException {
+        // add some action
+    }
+
+    @Override
+    public List<CrossPlatformResource> getList() throws InvalidOperationException, TException {
+        // add some action
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean ping() throws InvalidOperationException, TException {
+        return true;
+    }
+}

apache-thrift/src/main/java/com/baeldung/thrift/CrossPlatformServiceServer.java

@@ -0,0 +1,39 @@
+package com.baeldung.thrift;
+
+import com.baeldung.thrift.impl.CrossPlatformService;
+
+import org.apache.thrift.server.TServer;
+import org.apache.thrift.server.TSimpleServer;
+import org.apache.thrift.transport.TServerSocket;
+import org.apache.thrift.transport.TServerTransport;
+
+public class CrossPlatformServiceServer {
+
+    private TServer server;
+
+    public void start() {
+        try {
+            TServerTransport serverTransport = new TServerSocket(9090);
+            server = new TSimpleServer(new TServer.Args(serverTransport)
+                .processor(new CrossPlatformService.Processor<>(new CrossPlatformServiceImpl())));
+
+            System.out.print("Starting the server... ");
+
+            server.serve();
+
+            System.out.println("done.");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void stop() {
+        if (server != null && server.isServing()) {
+            System.out.print("Stopping the server... ");
+
+            server.stop();
+
+            System.out.println("done.");
+        }
+    }
+}

apache-thrift/src/main/resources/cross-platform-service.thrift

@@ -0,0 +1,24 @@
+namespace cpp com.baeldung.thrift.impl
+namespace java com.baeldung.thrift.impl
+
+exception InvalidOperationException {
+    1: i32 code,
+    2: string description
+}
+
+struct CrossPlatformResource {
+    1: i32 id,
+    2: string name,
+    3: optional string salutation
+}
+
+service CrossPlatformService {
+
+    CrossPlatformResource get(1:i32 id) throws (1:InvalidOperationException e),
+
+    void save(1:CrossPlatformResource resource) throws (1:InvalidOperationException e),
+
+    list <CrossPlatformResource> getList() throws (1:InvalidOperationException e),
+
+    bool ping() throws (1:InvalidOperationException e)
+}

apache-thrift/src/test/java/com/baeldung/thrift/CrossPlatformServiceTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.thrift;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class CrossPlatformServiceTest {
+
+    private CrossPlatformServiceServer server = new CrossPlatformServiceServer();
+
+    @Before
+    public void setUp() {
+        new Thread(() -> server.start()).start();
+        try {
+            // wait for the server start up
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @After
+    public void tearDown() {
+        server.stop();
+    }
+
+    @Test
+    public void ping() {
+        CrossPlatformServiceClient client = new CrossPlatformServiceClient();
+        Assert.assertTrue(client.ping());
+    }
+}

aspectj/README.md

@@ -1,2 +1,3 @@
 ### Relevant Articles:
 - [Intro to AspectJ](http://www.baeldung.com/aspectj)
+- [Spring Performance Logging](http://www.baeldung.com/spring-performance-logging)

aspectj/pom.xml

@@ -111,18 +111,8 @@
                     <Xlint>ignore</Xlint>
                     <encoding>${project.build.sourceEncoding}</encoding>
                     <!-- Post-compile weaving -->
-                    <!--
-                    <weaveDependencies>
-                        <weaveDependency>
-                              <groupId>org.agroup</groupId>
-                              <artifactId>to-weave</artifactId>
-                        </weaveDependency>
-                        <weaveDependency>
-                              <groupId>org.anothergroup</groupId>
-                              <artifactId>gen</artifactId>
-                        </weaveDependency>
-                      </weaveDependencies>
-                      -->
+                    <!-- <weaveDependencies> <weaveDependency> <groupId>org.agroup</groupId> <artifactId>to-weave</artifactId> </weaveDependency> 
+                        <weaveDependency> <groupId>org.anothergroup</groupId> <artifactId>gen</artifactId> </weaveDependency> </weaveDependencies> -->
                 </configuration>
                 <executions>
                     <execution>
@@ -134,18 +124,9 @@
                 </executions>
             </plugin>
 
-            <!-- 
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-surefire-plugin</artifactId>
-                <version>2.10</version>
-                <configuration>
-                    <argLine>-javaagent:"${settings.localRepository}"/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar</argLine>
-                    <useSystemClassLoader>true</useSystemClassLoader>
-                    <forkMode>always</forkMode>
-                </configuration>
-            </plugin>
-             -->
+            <!-- <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>2.10</version> 
+                <configuration> <argLine>-javaagent:"${settings.localRepository}"/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar</argLine> 
+                <useSystemClassLoader>true</useSystemClassLoader> <forkMode>always</forkMode> </configuration> </plugin> -->
         </plugins>
     </build>
 

assertj/src/test/java/com/baeldung/assertj/introduction/AssertJCoreTest.java

@@ -38,8 +38,7 @@ public class AssertJCoreTest {
     public void whenCheckingForElement_thenContains() throws Exception {
         List<String> list = Arrays.asList("1", "2", "3");
 
-        assertThat(list)
-                .contains("1");
+        assertThat(list).contains("1");
     }
 
     @Test
@@ -50,12 +49,7 @@ public class AssertJCoreTest {
         assertThat(list).startsWith("1");
         assertThat(list).doesNotContainNull();
 
-        assertThat(list)
-                .isNotEmpty()
-                .contains("1")
-                .startsWith("1")
-                .doesNotContainNull()
-                .containsSequence("2", "3");
+        assertThat(list).isNotEmpty().contains("1").startsWith("1").doesNotContainNull().containsSequence("2", "3");
     }
 
     @Test
@@ -67,11 +61,7 @@ public class AssertJCoreTest {
     public void whenCheckingCharacter_thenIsUnicode() throws Exception {
         char someCharacter = 'c';
 
-        assertThat(someCharacter)
-                .isNotEqualTo('a')
-                .inUnicode()
-                .isGreaterThanOrEqualTo('b')
-                .isLowerCase();
+        assertThat(someCharacter).isNotEqualTo('a').inUnicode().isGreaterThanOrEqualTo('b').isLowerCase();
     }
 
     @Test
@@ -94,11 +84,7 @@ public class AssertJCoreTest {
         final File someFile = File.createTempFile("aaa", "bbb");
         someFile.deleteOnExit();
 
-        assertThat(someFile)
-                .exists()
-                .isFile()
-                .canRead()
-                .canWrite();
+        assertThat(someFile).exists().isFile().canRead().canWrite();
     }
 
     @Test
@@ -113,20 +99,14 @@ public class AssertJCoreTest {
     public void whenGivenMap_then() throws Exception {
         Map<Integer, String> map = Maps.newHashMap(2, "a");
 
-        assertThat(map)
-                .isNotEmpty()
-                .containsKey(2)
-                .doesNotContainKeys(10)
-                .contains(entry(2, "a"));
+        assertThat(map).isNotEmpty().containsKey(2).doesNotContainKeys(10).contains(entry(2, "a"));
     }
 
     @Test
     public void whenGivenException_then() throws Exception {
         Exception ex = new Exception("abc");
 
-        assertThat(ex)
-                .hasNoCause()
-                .hasMessageEndingWith("c");
+        assertThat(ex).hasNoCause().hasMessageEndingWith("c");
     }
 
     @Ignore // IN ORDER TO TEST, REMOVE THIS LINE
@@ -134,8 +114,6 @@ public class AssertJCoreTest {
     public void whenRunningAssertion_thenDescribed() throws Exception {
         Person person = new Person("Alex", 34);
 
-        assertThat(person.getAge())
-                .as("%s's age should be equal to 100")
-                .isEqualTo(100);
+        assertThat(person.getAge()).as("%s's age should be equal to 100").isEqualTo(100);
     }
 }

assertj/src/test/java/com/baeldung/assertj/introduction/AssertJGuavaTest.java

@@ -26,9 +26,7 @@ public class AssertJGuavaTest {
         final File temp1 = File.createTempFile("bael", "dung1");
         final File temp2 = File.createTempFile("bael", "dung2");
 
-        assertThat(Files.asByteSource(temp1))
-                .hasSize(0)
-                .hasSameContentAs(Files.asByteSource(temp2));
+        assertThat(Files.asByteSource(temp1)).hasSize(0).hasSameContentAs(Files.asByteSource(temp2));
     }
 
     @Test
@@ -37,11 +35,7 @@ public class AssertJGuavaTest {
         mmap.put(1, "one");
         mmap.put(1, "1");
 
-        assertThat(mmap)
-                .hasSize(2)
-                .containsKeys(1)
-                .contains(entry(1, "one"))
-                .contains(entry(1, "1"));
+        assertThat(mmap).hasSize(2).containsKeys(1).contains(entry(1, "one")).contains(entry(1, "1"));
     }
 
     @Test
@@ -62,31 +56,21 @@ public class AssertJGuavaTest {
         mmap2.put(1, "one");
         mmap2.put(1, "1");
 
-        assertThat(mmap1)
-                .containsAllEntriesOf(mmap2)
-                .containsAllEntriesOf(mmap1_clone)
-                .hasSameEntriesAs(mmap1_clone);
+        assertThat(mmap1).containsAllEntriesOf(mmap2).containsAllEntriesOf(mmap1_clone).hasSameEntriesAs(mmap1_clone);
     }
 
     @Test
     public void givenOptional_whenVerifyingContent_thenShouldBeEqual() throws Exception {
         final Optional<String> something = Optional.of("something");
 
-        assertThat(something)
-                .isPresent()
-                .extractingValue()
-                .isEqualTo("something");
+        assertThat(something).isPresent().extractingValue().isEqualTo("something");
     }
 
     @Test
     public void givenRange_whenVerifying_thenShouldBeCorrect() throws Exception {
         final Range<String> range = Range.openClosed("a", "g");
 
-        assertThat(range)
-                .hasOpenedLowerBound()
-                .isNotEmpty()
-                .hasClosedUpperBound()
-                .contains("b");
+        assertThat(range).hasOpenedLowerBound().isNotEmpty().hasClosedUpperBound().contains("b");
     }
 
     @Test
@@ -96,10 +80,7 @@ public class AssertJGuavaTest {
         map.put(Range.closed(0, 60), "F");
         map.put(Range.closed(61, 70), "D");
 
-        assertThat(map)
-                .isNotEmpty()
-                .containsKeys(0)
-                .contains(MapEntry.entry(34, "F"));
+        assertThat(map).isNotEmpty().containsKeys(0).contains(MapEntry.entry(34, "F"));
     }
 
     @Test
@@ -109,13 +90,7 @@ public class AssertJGuavaTest {
         table.put(1, "A", "PRESENT");
         table.put(1, "B", "ABSENT");
 
-        assertThat(table)
-                .hasRowCount(1)
-                .containsValues("ABSENT")
-                .containsCell(1, "B", "ABSENT");
+        assertThat(table).hasRowCount(1).containsValues("ABSENT").containsCell(1, "B", "ABSENT");
     }
 
-
-
-
 }

assertj/src/test/java/com/baeldung/assertj/introduction/AssertJJava8Test.java

@@ -20,20 +20,14 @@ public class AssertJJava8Test {
     public void givenOptional_shouldAssert() throws Exception {
         final Optional<String> givenOptional = Optional.of("something");
 
-        assertThat(givenOptional)
-          .isPresent()
-          .hasValue("something");
+        assertThat(givenOptional).isPresent().hasValue("something");
     }
 
     @Test
     public void givenPredicate_shouldAssert() throws Exception {
         final Predicate<String> predicate = s -> s.length() > 4;
 
-        assertThat(predicate)
-          .accepts("aaaaa", "bbbbb")
-          .rejects("a", "b")
-          .acceptsAll(asList("aaaaa", "bbbbb"))
-          .rejectsAll(asList("a", "b"));
+        assertThat(predicate).accepts("aaaaa", "bbbbb").rejects("a", "b").acceptsAll(asList("aaaaa", "bbbbb")).rejectsAll(asList("a", "b"));
     }
 
     @Test
@@ -41,74 +35,58 @@ public class AssertJJava8Test {
         final LocalDate givenLocalDate = LocalDate.of(2016, 7, 8);
         final LocalDate todayDate = LocalDate.now();
 
-        assertThat(givenLocalDate)
-          .isBefore(LocalDate.of(2020, 7, 8))
-          .isAfterOrEqualTo(LocalDate.of(1989, 7, 8));
+        assertThat(givenLocalDate).isBefore(LocalDate.of(2020, 7, 8)).isAfterOrEqualTo(LocalDate.of(1989, 7, 8));
 
-        assertThat(todayDate)
-          .isAfter(LocalDate.of(1989, 7, 8))
-          .isToday();
+        assertThat(todayDate).isAfter(LocalDate.of(1989, 7, 8)).isToday();
     }
 
     @Test
     public void givenLocalDateTime_shouldAssert() throws Exception {
         final LocalDateTime givenLocalDate = LocalDateTime.of(2016, 7, 8, 12, 0);
 
-        assertThat(givenLocalDate)
-          .isBefore(LocalDateTime.of(2020, 7, 8, 11, 2));
+        assertThat(givenLocalDate).isBefore(LocalDateTime.of(2020, 7, 8, 11, 2));
     }
 
     @Test
     public void givenLocalTime_shouldAssert() throws Exception {
         final LocalTime givenLocalTime = LocalTime.of(12, 15);
 
-        assertThat(givenLocalTime)
-          .isAfter(LocalTime.of(1, 0))
-          .hasSameHourAs(LocalTime.of(12, 0));
+        assertThat(givenLocalTime).isAfter(LocalTime.of(1, 0)).hasSameHourAs(LocalTime.of(12, 0));
     }
 
     @Test
     public void givenList_shouldAssertFlatExtracting() throws Exception {
         final List<LocalDate> givenList = asList(ofYearDay(2016, 5), ofYearDay(2015, 6));
 
-        assertThat(givenList)
-          .flatExtracting(LocalDate::getYear)
-          .contains(2015);
+        assertThat(givenList).flatExtracting(LocalDate::getYear).contains(2015);
     }
 
     @Test
     public void givenList_shouldAssertFlatExtractingLeapYear() throws Exception {
         final List<LocalDate> givenList = asList(ofYearDay(2016, 5), ofYearDay(2015, 6));
 
-        assertThat(givenList)
-          .flatExtracting(LocalDate::isLeapYear)
-          .contains(true);
+        assertThat(givenList).flatExtracting(LocalDate::isLeapYear).contains(true);
     }
 
     @Test
     public void givenList_shouldAssertFlatExtractingClass() throws Exception {
         final List<LocalDate> givenList = asList(ofYearDay(2016, 5), ofYearDay(2015, 6));
 
-        assertThat(givenList)
-          .flatExtracting(Object::getClass)
-          .contains(LocalDate.class);
+        assertThat(givenList).flatExtracting(Object::getClass).contains(LocalDate.class);
     }
 
     @Test
     public void givenList_shouldAssertMultipleFlatExtracting() throws Exception {
         final List<LocalDate> givenList = asList(ofYearDay(2016, 5), ofYearDay(2015, 6));
 
-        assertThat(givenList)
-          .flatExtracting(LocalDate::getYear, LocalDate::getDayOfMonth)
-          .contains(2015, 6);
+        assertThat(givenList).flatExtracting(LocalDate::getYear, LocalDate::getDayOfMonth).contains(2015, 6);
     }
 
     @Test
     public void givenString_shouldSatisfy() throws Exception {
         final String givenString = "someString";
 
-        assertThat(givenString)
-          .satisfies(s -> {
+        assertThat(givenString).satisfies(s -> {
             assertThat(s).isNotEmpty();
             assertThat(s).hasSize(10);
         });
@@ -118,15 +96,13 @@ public class AssertJJava8Test {
     public void givenString_shouldMatch() throws Exception {
         final String emptyString = "";
 
-        assertThat(emptyString)
-          .matches(String::isEmpty);
+        assertThat(emptyString).matches(String::isEmpty);
     }
 
     @Test
     public void givenList_shouldHasOnlyOneElementSatisfying() throws Exception {
         final List<String> givenList = Arrays.asList("");
 
-        assertThat(givenList)
-          .hasOnlyOneElementSatisfying(s -> assertThat(s).isEmpty());
+        assertThat(givenList).hasOnlyOneElementSatisfying(s -> assertThat(s).isEmpty());
     }
 }

autovalue/src/main/java/com/baeldung/autovalue/ImmutableMoney.java

@@ -1,18 +1,20 @@
 package com.baeldung.autovalue;
+
 public final class ImmutableMoney {
     private final long amount;
     private final String currency;
+
     public ImmutableMoney(long amount, String currency) {
         this.amount = amount;
         this.currency = currency;
     }
+
     @Override
     public int hashCode() {
         final int prime = 31;
         int result = 1;
         result = prime * result + (int) (amount ^ (amount >>> 32));
-		result = prime * result
-				+ ((currency == null) ? 0 : currency.hashCode());
+        result = prime * result + ((currency == null) ? 0 : currency.hashCode());
         return result;
     }
 
@@ -45,8 +47,7 @@ public final class ImmutableMoney {
 
     @Override
     public String toString() {
-		return "ImmutableMoney [amount=" + amount + ", currency=" + currency
-				+ "]";
+        return "ImmutableMoney [amount=" + amount + ", currency=" + currency + "]";
     }
 
 }

autovalue/src/main/java/com/baeldung/autovalue/MutableMoney.java

@@ -3,8 +3,7 @@ package com.baeldung.autovalue;
 public class MutableMoney {
     @Override
     public String toString() {
-		return "MutableMoney [amount=" + amount + ", currency=" + currency
-				+ "]";
+        return "MutableMoney [amount=" + amount + ", currency=" + currency + "]";
     }
 
     public long getAmount() {

autovalue/src/test/java/com/baeldung/autovalue/MoneyUnitTest.java

@@ -32,24 +32,28 @@ public class MoneyUnitTest {
         AutoValueMoney m2 = AutoValueMoney.create("USD", 5000);
         assertTrue(m1.equals(m2));
     }
+
     @Test
     public void given2DifferentValueTypesWithAutoValue_whenNotEqual_thenCorrect() {
         AutoValueMoney m1 = AutoValueMoney.create("GBP", 5000);
         AutoValueMoney m2 = AutoValueMoney.create("USD", 5000);
         assertFalse(m1.equals(m2));
     }
+
     @Test
     public void given2EqualValueTypesWithBuilder_whenEqual_thenCorrect() {
         AutoValueMoneyWithBuilder m1 = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("USD").build();
         AutoValueMoneyWithBuilder m2 = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("USD").build();
         assertTrue(m1.equals(m2));
     }
+
     @Test
     public void given2DifferentValueTypesBuilder_whenNotEqual_thenCorrect() {
         AutoValueMoneyWithBuilder m1 = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("USD").build();
         AutoValueMoneyWithBuilder m2 = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("GBP").build();
         assertFalse(m1.equals(m2));
     }
+
     @Test
     public void givenValueTypeWithBuilder_whenFieldsCorrectlySet_thenCorrect() {
         AutoValueMoneyWithBuilder m = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("USD").build();

core-java-9/pom.xml

@@ -1,5 +1,4 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" 
-		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.baeldung</groupId>
@@ -23,8 +22,6 @@
             <version>${org.slf4j.version}</version>
         </dependency>
 
-
-
         <dependency>
             <groupId>org.hamcrest</groupId>
             <artifactId>hamcrest-library</artifactId>
@@ -60,7 +57,6 @@
                 <configuration>
                     <source>1.9</source>
                     <target>1.9</target>
-					<verbose>true</verbose>
                 </configuration>
             </plugin>
 
@@ -75,6 +71,9 @@
     </build>
 
     <properties>
+        <!-- project build encoding -->
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    
         <!-- logging -->
         <org.slf4j.version>1.7.21</org.slf4j.version>
 

core-java-9/src/main/java/com/baeldung/java9/language/PrivateInterface.java

@@ -10,7 +10,7 @@ public interface PrivateInterface {
         return "instance private";
     }
 
-    public default void check(){
+    public default void check() {
         String result = staticPrivate();
         if (!result.equals("static private"))
             throw new AssertionError("Incorrect result for static private interface method");

core-java-9/src/main/java/com/baeldung/java9/process/ProcessUtils.java

@@ -8,37 +8,36 @@ import java.time.Duration;
 import java.time.Instant;
 import java.util.stream.Stream;
 
-
 public class ProcessUtils {
 
-    public static String getClassPath(){
+    public static String getClassPath() {
         String cp = System.getProperty("java.class.path");
-        System.out.println("ClassPath is "+cp);
+        System.out.println("ClassPath is " + cp);
         return cp;
     }
 
-    public static File getJavaCmd() throws IOException{
+    public static File getJavaCmd() throws IOException {
         String javaHome = System.getProperty("java.home");
         File javaCmd;
-        if(System.getProperty("os.name").startsWith("Win")){
+        if (System.getProperty("os.name").startsWith("Win")) {
             javaCmd = new File(javaHome, "bin/java.exe");
-        }else{
+        } else {
             javaCmd = new File(javaHome, "bin/java");
         }
-        if(javaCmd.canExecute()){
+        if (javaCmd.canExecute()) {
             return javaCmd;
-        }else{
+        } else {
             throw new UnsupportedOperationException(javaCmd.getCanonicalPath() + " is not executable");
         }
     }
 
-    public static String getMainClass(){
+    public static String getMainClass() {
         return System.getProperty("sun.java.command");
     }
 
-    public static String getSystemProperties(){
+    public static String getSystemProperties() {
         StringBuilder sb = new StringBuilder();
-        System.getProperties().forEach((s1, s2) -> sb.append(s1 +" - "+ s2) );
+        System.getProperties().forEach((s1, s2) -> sb.append(s1 + " - " + s2));
         return sb.toString();
     }
 }

core-java-9/src/main/java/com/baeldung/java9/process/ServiceMain.java

@@ -8,7 +8,6 @@ public class ServiceMain {
         ProcessHandle thisProcess = ProcessHandle.current();
         long pid = thisProcess.getPid();
 
-        
         Optional<String[]> opArgs = Optional.ofNullable(args);
         String procName = opArgs.map(str -> str.length > 0 ? str[0] : null).orElse(System.getProperty("sun.java.command"));
 

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

@@ -19,10 +19,7 @@ public class Java9OptionalsStreamTest {
     public void filterOutPresentOptionalsWithFilter() {
         assertEquals(4, listOfOptionals.size());
 
-        List<String> filteredList = listOfOptionals.stream()
-          .filter(Optional::isPresent)
-          .map(Optional::get)
-          .collect(Collectors.toList());
+        List<String> filteredList = listOfOptionals.stream().filter(Optional::isPresent).map(Optional::get).collect(Collectors.toList());
 
         assertEquals(2, filteredList.size());
         assertEquals("foo", filteredList.get(0));
@@ -33,9 +30,7 @@ public class Java9OptionalsStreamTest {
     public void filterOutPresentOptionalsWithFlatMap() {
         assertEquals(4, listOfOptionals.size());
 
-        List<String> filteredList = listOfOptionals.stream()
-          .flatMap(o -> o.isPresent() ? Stream.of(o.get()) : Stream.empty())
-          .collect(Collectors.toList());
+        List<String> filteredList = listOfOptionals.stream().flatMap(o -> o.isPresent() ? Stream.of(o.get()) : Stream.empty()).collect(Collectors.toList());
         assertEquals(2, filteredList.size());
 
         assertEquals("foo", filteredList.get(0));
@@ -46,9 +41,7 @@ public class Java9OptionalsStreamTest {
     public void filterOutPresentOptionalsWithFlatMap2() {
         assertEquals(4, listOfOptionals.size());
 
-        List<String> filteredList = listOfOptionals.stream()
-          .flatMap(o -> o.map(Stream::of).orElseGet(Stream::empty))
-          .collect(Collectors.toList());
+        List<String> filteredList = listOfOptionals.stream().flatMap(o -> o.map(Stream::of).orElseGet(Stream::empty)).collect(Collectors.toList());
         assertEquals(2, filteredList.size());
 
         assertEquals("foo", filteredList.get(0));
@@ -59,9 +52,7 @@ public class Java9OptionalsStreamTest {
     public void filterOutPresentOptionalsWithJava9() {
         assertEquals(4, listOfOptionals.size());
 
-        List<String> filteredList = listOfOptionals.stream()
-          .flatMap(Optional::stream)
-          .collect(Collectors.toList());
+        List<String> filteredList = listOfOptionals.stream().flatMap(Optional::stream).collect(Collectors.toList());
 
         assertEquals(2, filteredList.size());
         assertEquals("foo", filteredList.get(0));

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

@@ -13,7 +13,6 @@ import org.junit.Test;
 
 public class MultiResultionImageTest {
 
-
     @Test
     public void baseMultiResImageTest() {
         int baseIndex = 1;
@@ -38,10 +37,8 @@ public class MultiResultionImageTest {
         return 8 * (i + 1);
     }
 
-
     private static BufferedImage createImage(int i) {
-        return new BufferedImage(getSize(i), getSize(i),
-                BufferedImage.TYPE_INT_RGB);
+        return new BufferedImage(getSize(i), getSize(i), BufferedImage.TYPE_INT_RGB);
     }
 
 }

core-java-9/src/test/java/com/baeldung/java9/httpclient/SimpleHttpRequestsTest.java

@@ -1,7 +1,5 @@
 package com.baeldung.java9.httpclient;
 
-
-
 import static java.net.HttpURLConnection.HTTP_OK;
 import static org.junit.Assert.assertTrue;
 
@@ -37,7 +35,7 @@ public class SimpleHttpRequestsTest {
 
     @Test
     public void quickGet() throws IOException, InterruptedException, URISyntaxException {
-        HttpRequest request = HttpRequest.create( httpURI ).GET();
+        HttpRequest request = HttpRequest.create(httpURI).GET();
         HttpResponse response = request.response();
         int responseStatusCode = response.statusCode();
         String responseBody = response.body(HttpResponse.asString());
@@ -45,16 +43,16 @@ public class SimpleHttpRequestsTest {
     }
 
     @Test
-    public void asynchronousGet() throws URISyntaxException, IOException, InterruptedException, ExecutionException{
+    public void asynchronousGet() throws URISyntaxException, IOException, InterruptedException, ExecutionException {
         HttpRequest request = HttpRequest.create(httpURI).GET();
         long before = System.currentTimeMillis();
         CompletableFuture<HttpResponse> futureResponse = request.responseAsync();
-        futureResponse.thenAccept( response -> {
+        futureResponse.thenAccept(response -> {
             String responseBody = response.body(HttpResponse.asString());
         });
         HttpResponse resp = futureResponse.get();
         HttpHeaders hs = resp.headers();
-        assertTrue("There should be more then 1 header.", hs.map().size() >1);
+        assertTrue("There should be more then 1 header.", hs.map().size() > 1);
     }
 
     @Test
@@ -68,11 +66,11 @@ public class SimpleHttpRequestsTest {
     }
 
     @Test
-    public void configureHttpClient() throws NoSuchAlgorithmException, URISyntaxException, IOException, InterruptedException{
+    public void configureHttpClient() throws NoSuchAlgorithmException, URISyntaxException, IOException, InterruptedException {
         CookieManager cManager = new CookieManager();
         cManager.setCookiePolicy(CookiePolicy.ACCEPT_ORIGINAL_SERVER);
 
-        SSLParameters sslParam = new SSLParameters (new String[] { "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256" }, new String[] { "TLSv1.2" });
+        SSLParameters sslParam = new SSLParameters(new String[] { "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256" }, new String[] { "TLSv1.2" });
 
         HttpClient.Builder hcBuilder = HttpClient.create();
         hcBuilder.cookieManager(cManager).sslContext(SSLContext.getDefault()).sslParameters(sslParam);
@@ -85,39 +83,41 @@ public class SimpleHttpRequestsTest {
         assertTrue("HTTP return code", statusCode == HTTP_OK);
     }
 
-    SSLParameters getDefaultSSLParameters() throws NoSuchAlgorithmException{
+    SSLParameters getDefaultSSLParameters() throws NoSuchAlgorithmException {
         SSLParameters sslP1 = SSLContext.getDefault().getSupportedSSLParameters();
-        String [] proto = sslP1.getApplicationProtocols();
-        String [] cifers = sslP1.getCipherSuites();
+        String[] proto = sslP1.getApplicationProtocols();
+        String[] cifers = sslP1.getCipherSuites();
         System.out.println(printStringArr(proto));
         System.out.println(printStringArr(cifers));
         return sslP1;
     }
 
-    String printStringArr(String ... args ){
-        if(args == null){
+    String printStringArr(String... args) {
+        if (args == null) {
             return null;
         }
         StringBuilder sb = new StringBuilder();
-        for (String s : args){
+        for (String s : args) {
             sb.append(s);
             sb.append("\n");
         }
         return sb.toString();
     }
 
-    String printHeaders(HttpHeaders h){
-        if(h == null){
+    String printHeaders(HttpHeaders h) {
+        if (h == null) {
             return null;
         }
 
         StringBuilder sb = new StringBuilder();
         Map<String, List<String>> hMap = h.map();
-       for(String k : hMap.keySet()){
+        for (String k : hMap.keySet()) {
             sb.append(k).append(":");
             List<String> l = hMap.get(k);
-           if( l != null ){
-               l.forEach( s -> { sb.append(s).append(","); } );
+            if (l != null) {
+                l.forEach(s -> {
+                    sb.append(s).append(",");
+                });
             }
             sb.append("\n");
         }

core-java-9/src/test/java/com/baeldung/java9/language/TryWithResourcesTest.java

@@ -7,7 +7,7 @@ public class TryWithResourcesTest {
 
     static int closeCount = 0;
 
-    static class MyAutoCloseable implements AutoCloseable{
+    static class MyAutoCloseable implements AutoCloseable {
         final FinalWrapper finalWrapper = new FinalWrapper();
 
         public void close() {
@@ -57,7 +57,6 @@ public class TryWithResourcesTest {
         assertEquals("Expected and Actual does not match", 5, closeCount);
     }
 
-
     static class CloseableException extends Exception implements AutoCloseable {
         @Override
         public void close() {
@@ -66,5 +65,3 @@ public class TryWithResourcesTest {
     }
 
 }
-
-

core-java-9/src/test/java/com/baeldung/java9/language/collections/ListFactoryMethodsTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.java9.language.collections;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+public class ListFactoryMethodsTest {
+
+    @Test
+    public void whenListCreated_thenSuccess() {
+        List<String> traditionlList = new ArrayList<String>();
+        traditionlList.add("foo");
+        traditionlList.add("bar");
+        traditionlList.add("baz");
+        List<String> factoryCreatedList = List.of("foo", "bar", "baz");
+        assertEquals(traditionlList, factoryCreatedList);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void onElemAdd_ifUnSupportedOpExpnThrown_thenSuccess() {
+        List<String> list = List.of("foo", "bar");
+        list.add("baz");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void onElemModify_ifUnSupportedOpExpnThrown_thenSuccess() {
+        List<String> list = List.of("foo", "bar");
+        list.set(0, "baz");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void onElemRemove_ifUnSupportedOpExpnThrown_thenSuccess() {
+        List<String> list = List.of("foo", "bar");
+        list.remove("foo");
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void onNullElem_ifNullPtrExpnThrown_thenSuccess() {
+        List.of("foo", "bar", null);
+    }
+
+    @Test
+    public void ifNotArrayList_thenSuccess() {
+        List<String> list = List.of("foo", "bar");
+        assertFalse(list instanceof ArrayList);
+    }
+
+    @Test
+    public void ifListSizeIsOne_thenSuccess() {
+        int[] arr = { 1, 2, 3, 4 };
+        List<int[]> list = List.of(arr);
+        assertEquals(1, list.size());
+        assertArrayEquals(arr, list.get(0));
+    }
+
+}

core-java-9/src/test/java/com/baeldung/java9/language/collections/MapFactoryMethodsTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.java9.language.collections;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+public class MapFactoryMethodsTest {
+
+    @Test
+    public void whenMapCreated_thenSuccess() {
+        Map<String, String> traditionlMap = new HashMap<String, String>();
+        traditionlMap.put("foo", "a");
+        traditionlMap.put("bar", "b");
+        traditionlMap.put("baz", "c");
+        Map<String, String> factoryCreatedMap = Map.of("foo", "a", "bar", "b", "baz", "c");
+        assertEquals(traditionlMap, factoryCreatedMap);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void onElemAdd_ifUnSupportedOpExpnThrown_thenSuccess() {
+        Map<String, String> map = Map.of("foo", "a", "bar", "b");
+        map.put("baz", "c");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void onElemModify_ifUnSupportedOpExpnThrown_thenSuccess() {
+        Map<String, String> map = Map.of("foo", "a", "bar", "b");
+        map.put("foo", "c");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void onElemRemove_ifUnSupportedOpExpnThrown_thenSuccess() {
+        Map<String, String> map = Map.of("foo", "a", "bar", "b");
+        map.remove("foo");
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void givenDuplicateKeys_ifIllegalArgExp_thenSuccess() {
+        Map.of("foo", "a", "foo", "b");
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void onNullKey_ifNullPtrExp_thenSuccess() {
+        Map.of("foo", "a", null, "b");
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void onNullValue_ifNullPtrExp_thenSuccess() {
+        Map.of("foo", "a", "bar", null);
+    }
+
+    @Test
+    public void ifNotHashMap_thenSuccess() {
+        Map<String, String> map = Map.of("foo", "a", "bar", "b");
+        assertFalse(map instanceof HashMap);
+    }
+
+}

core-java-9/src/test/java/com/baeldung/java9/language/collections/SetFactoryMethodsTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.java9.language.collections;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+public class SetFactoryMethodsTest {
+
+    @Test
+    public void whenSetCreated_thenSuccess() {
+        Set<String> traditionlSet = new HashSet<String>();
+        traditionlSet.add("foo");
+        traditionlSet.add("bar");
+        traditionlSet.add("baz");
+        Set<String> factoryCreatedSet = Set.of("foo", "bar", "baz");
+        assertEquals(traditionlSet, factoryCreatedSet);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void onDuplicateElem_IfIllegalArgExp_thenSuccess() {
+        Set.of("foo", "bar", "baz", "foo");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void onElemAdd_ifUnSupportedOpExpnThrown_thenSuccess() {
+        Set<String> set = Set.of("foo", "bar");
+        set.add("baz");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void onElemRemove_ifUnSupportedOpExpnThrown_thenSuccess() {
+        Set<String> set = Set.of("foo", "bar", "baz");
+        set.remove("foo");
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void onNullElem_ifNullPtrExpnThrown_thenSuccess() {
+        Set.of("foo", "bar", null);
+    }
+
+    @Test
+    public void ifNotHashSet_thenSuccess() {
+        Set<String> list = Set.of("foo", "bar");
+        assertFalse(list instanceof HashSet);
+    }
+
+    @Test
+    public void ifSetSizeIsOne_thenSuccess() {
+        int[] arr = { 1, 2, 3, 4 };
+        Set<int[]> set = Set.of(arr);
+        assertEquals(1, set.size());
+        assertArrayEquals(arr, set.iterator().next());
+    }
+
+}

core-java-9/src/test/java/com/baeldung/java9/language/stream/CollectorImprovementTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.java9.language.stream;
+
+import org.junit.Test;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.function.Function;
+
+import static org.junit.Assert.assertEquals;
+
+public class CollectorImprovementTest {
+    @Test
+    public void givenList_whenSatifyPredicate_thenMapValueWithOccurences() {
+        List<Integer> numbers = List.of(1, 2, 3, 5, 5);
+
+        Map<Integer, Long> result = numbers.stream().filter(val -> val > 3).collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
+
+        assertEquals(1, result.size());
+
+        result = numbers.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.filtering(val -> val > 3, Collectors.counting())));
+
+        assertEquals(4, result.size());
+    }
+
+    @Test
+    public void givenListOfBlogs_whenAuthorName_thenMapAuthorWithComments() {
+        Blog blog1 = new Blog("1", "Nice", "Very Nice");
+        Blog blog2 = new Blog("2", "Disappointing", "Ok", "Could be better");
+        List<Blog> blogs = List.of(blog1, blog2);
+
+        Map<String, List<List<String>>> authorComments1 = blogs.stream().collect(Collectors.groupingBy(Blog::getAuthorName, Collectors.mapping(Blog::getComments, Collectors.toList())));
+
+        assertEquals(2, authorComments1.size());
+        assertEquals(2, authorComments1.get("1").get(0).size());
+        assertEquals(3, authorComments1.get("2").get(0).size());
+
+        Map<String, List<String>> authorComments2 = blogs.stream().collect(Collectors.groupingBy(Blog::getAuthorName, Collectors.flatMapping(blog -> blog.getComments().stream(), Collectors.toList())));
+
+        assertEquals(2, authorComments2.size());
+        assertEquals(2, authorComments2.get("1").size());
+        assertEquals(3, authorComments2.get("2").size());
+    }
+}
+
+class Blog {
+    private String authorName;
+    private List<String> comments;
+
+    public Blog(String authorName, String... comments) {
+        this.authorName = authorName;
+        this.comments = List.of(comments);
+    }
+
+    public String getAuthorName() {
+        return this.authorName;
+    }
+
+    public List<String> getComments() {
+        return this.comments;
+    }
+}

core-java-9/src/test/java/com/baeldung/java9/language/stream/StreamFeaturesTest.java

@@ -17,16 +17,11 @@ public class StreamFeaturesTest {
     public static class TakeAndDropWhileTest {
 
         public Stream<String> getStreamAfterTakeWhileOperation() {
-            return Stream
-                    .iterate("", s -> s + "s")
-                    .takeWhile(s -> s.length() < 10);
+            return Stream.iterate("", s -> s + "s").takeWhile(s -> s.length() < 10);
         }
 
         public Stream<String> getStreamAfterDropWhileOperation() {
-            return Stream
-                    .iterate("", s -> s + "s")
-                    .takeWhile(s -> s.length() < 10)
-                    .dropWhile(s -> !s.contains("sssss"));
+            return Stream.iterate("", s -> s + "s").takeWhile(s -> s.length() < 10).dropWhile(s -> !s.contains("sssss"));
         }
 
         @Test
@@ -75,19 +70,19 @@ public class StreamFeaturesTest {
     public static class OfNullableTest {
 
         private List<String> collection = Arrays.asList("A", "B", "C");
-        private Map<String, Integer> map = new HashMap<>() {{
+        private Map<String, Integer> map = new HashMap<>() {
+            {
                 put("A", 10);
                 put("C", 30);
-        }};
+            }
+        };
 
         private Stream<Integer> getStreamWithOfNullable() {
-            return collection.stream()
-                    .flatMap(s -> Stream.ofNullable(map.get(s)));
+            return collection.stream().flatMap(s -> Stream.ofNullable(map.get(s)));
         }
 
         private Stream<Integer> getStream() {
-            return collection.stream()
-                            .flatMap(s -> {
+            return collection.stream().flatMap(s -> {
                 Integer temp = map.get(s);
                 return temp != null ? Stream.of(temp) : Stream.empty();
             });
@@ -107,10 +102,7 @@ public class StreamFeaturesTest {
         @Test
         public void testOfNullable() {
 
-            assertEquals(
-                    testOfNullableFrom(getStream()),
-                    testOfNullableFrom(getStreamWithOfNullable())
-            );
+            assertEquals(testOfNullableFrom(getStream()), testOfNullableFrom(getStreamWithOfNullable()));
 
         }
 

core-java-9/src/test/java/com/baeldung/java9/process/ProcessApi.java

@@ -22,14 +22,13 @@ import static org.junit.Assert.assertTrue;
 
 public class ProcessApi {
 
-
     @Before
     public void init() {
 
     }
 
     @Test
-    public void processInfoExample()throws NoSuchAlgorithmException{
+    public void processInfoExample() throws NoSuchAlgorithmException {
         ProcessHandle self = ProcessHandle.current();
         long PID = self.getPid();
         ProcessHandle.Info procInfo = self.info();
@@ -39,34 +38,34 @@ public class ProcessApi {
         Optional<Duration> cpuUsage = procInfo.totalCpuDuration();
 
         waistCPU();
-        System.out.println("Args "+ args);
-        System.out.println("Command " +cmd.orElse("EmptyCmd"));
-        System.out.println("Start time: "+ startTime.get().toString());
+        System.out.println("Args " + args);
+        System.out.println("Command " + cmd.orElse("EmptyCmd"));
+        System.out.println("Start time: " + startTime.get().toString());
         System.out.println(cpuUsage.get().toMillis());
 
         Stream<ProcessHandle> allProc = ProcessHandle.current().children();
         allProc.forEach(p -> {
-            System.out.println("Proc "+ p.getPid());
+            System.out.println("Proc " + p.getPid());
         });
 
     }
 
     @Test
-    public void createAndDestroyProcess() throws IOException, InterruptedException{
+    public void createAndDestroyProcess() throws IOException, InterruptedException {
         int numberOfChildProcesses = 5;
-        for(int i=0; i < numberOfChildProcesses; i++){
+        for (int i = 0; i < numberOfChildProcesses; i++) {
             createNewJVM(ServiceMain.class, i).getPid();
         }
 
         Stream<ProcessHandle> childProc = ProcessHandle.current().children();
-        assertEquals( childProc.count(), numberOfChildProcesses);      
+        assertEquals(childProc.count(), numberOfChildProcesses);
 
         childProc = ProcessHandle.current().children();
         childProc.forEach(processHandle -> {
-            assertTrue("Process "+ processHandle.getPid() +" should be alive!", processHandle.isAlive());
+            assertTrue("Process " + processHandle.getPid() + " should be alive!", processHandle.isAlive());
             CompletableFuture<ProcessHandle> onProcExit = processHandle.onExit();
             onProcExit.thenAccept(procHandle -> {
-                System.out.println("Process with PID "+ procHandle.getPid() + " has stopped");
+                System.out.println("Process with PID " + procHandle.getPid() + " has stopped");
             });
         });
 
@@ -74,38 +73,38 @@ public class ProcessApi {
 
         childProc = ProcessHandle.current().children();
         childProc.forEach(procHandle -> {
-            assertTrue("Could not kill process "+procHandle.getPid(), procHandle.destroy());
+            assertTrue("Could not kill process " + procHandle.getPid(), procHandle.destroy());
         });
 
         Thread.sleep(5000);
 
         childProc = ProcessHandle.current().children();
         childProc.forEach(procHandle -> {
-            assertFalse("Process "+ procHandle.getPid() +" should not be alive!", procHandle.isAlive());
+            assertFalse("Process " + procHandle.getPid() + " should not be alive!", procHandle.isAlive());
         });
 
     }
 
-    private Process createNewJVM(Class mainClass, int number) throws IOException{
+    private Process createNewJVM(Class mainClass, int number) throws IOException {
         ArrayList<String> cmdParams = new ArrayList<String>(5);
         cmdParams.add(ProcessUtils.getJavaCmd().getAbsolutePath());
         cmdParams.add("-cp");
         cmdParams.add(ProcessUtils.getClassPath());
         cmdParams.add(mainClass.getName());
-        cmdParams.add("Service "+ number);
+        cmdParams.add("Service " + number);
         ProcessBuilder myService = new ProcessBuilder(cmdParams);
         myService.inheritIO();
         return myService.start();
     }
 
-    private void waistCPU() throws NoSuchAlgorithmException{
+    private void waistCPU() throws NoSuchAlgorithmException {
         ArrayList<Integer> randArr = new ArrayList<Integer>(4096);
         SecureRandom sr = SecureRandom.getInstanceStrong();
         Duration somecpu = Duration.ofMillis(4200L);
         Instant end = Instant.now().plus(somecpu);
         while (Instant.now().isBefore(end)) {
-            //System.out.println(sr.nextInt());
-            randArr.add( sr.nextInt() );
+            // System.out.println(sr.nextInt());
+            randArr.add(sr.nextInt());
         }
     }
 

core-java/.gitignore

@@ -16,3 +16,7 @@
 *.txt
 /bin/
 /temp
+
+#IntelliJ specific
+.idea
+*.iml

core-java/README.md

@@ -53,3 +53,7 @@
 - [Calculate the Size of a File in Java](http://www.baeldung.com/java-file-size)
 - [The Basics of Java Generics](http://www.baeldung.com/java-generics)
 - [The Traveling Salesman Problem in Java](http://www.baeldung.com/java-simulated-annealing-for-traveling-salesman)
+- [How to Create an Executable JAR with Maven](http://www.baeldung.com/executable-jar-with-maven)
+- [Guide to java.util.concurrent.Future](http://www.baeldung.com/java-future)
+- [Guide to java.util.concurrent.BlockingQueue](http://www.baeldung.com/java-blocking-queue)
+- [Guide to CountDownLatch in Java](http://www.baeldung.com/java-countdown-latch)

core-java/pom.xml

@@ -63,6 +63,7 @@
             <artifactId>grep4j</artifactId>
             <version>${grep4j.version}</version>
         </dependency>
+        
         <!-- web -->
 
         <!-- marshalling -->
@@ -352,7 +353,7 @@
         <logback.version>1.1.7</logback.version>
 
         <!-- util -->
-        <guava.version>19.0</guava.version>
+        <guava.version>21.0</guava.version>
         <commons-lang3.version>3.5</commons-lang3.version>
         <bouncycastle.version>1.55</bouncycastle.version>
         <commons-codec.version>1.10</commons-codec.version>

core-java/src/main/java/com/baeldung/algorithms/RunAlgorithm.java

@@ -15,8 +15,7 @@ public class RunAlgorithm {
         int decision = in.nextInt();
         switch (decision) {
         case 1:
-			System.out.println(
-					"Optimized distance for travel: " + SimulatedAnnealing.simulateAnnealing(10, 10000, 0.9995));
+            System.out.println("Optimized distance for travel: " + SimulatedAnnealing.simulateAnnealing(10, 10000, 0.9995));
             break;
         case 2:
             SlopeOne.slopeOne(3);

core-java/src/main/java/com/baeldung/algorithms/slope_one/InputData.java

@@ -12,8 +12,7 @@ import lombok.Data;
 @Data
 public class InputData {
 
-	protected static List<Item> items = Arrays.asList(new Item("Candy"), new Item("Drink"), new Item("Soda"), new Item("Popcorn"),
-			new Item("Snacks"));
+    protected static List<Item> items = Arrays.asList(new Item("Candy"), new Item("Drink"), new Item("Soda"), new Item("Popcorn"), new Item("Snacks"));
 
     public static Map<User, HashMap<Item, Double>> initializeData(int numberOfUsers) {
         Map<User, HashMap<Item, Double>> data = new HashMap<>();

core-java/src/main/java/com/baeldung/chainedexception/LogWithChain.java

@@ -0,0 +1,41 @@
+package com.baeldung.chainedexception;
+
+import com.baeldung.chainedexception.exceptions.GirlFriendOfManagerUpsetException;
+import com.baeldung.chainedexception.exceptions.ManagerUpsetException;
+import com.baeldung.chainedexception.exceptions.NoLeaveGrantedException;
+import com.baeldung.chainedexception.exceptions.TeamLeadUpsetException;
+
+public class LogWithChain {
+
+    public static void main(String[] args) throws Exception {
+        getLeave();
+    }
+
+    private static void getLeave() throws NoLeaveGrantedException {
+        try {
+            howIsTeamLead();
+        } catch (TeamLeadUpsetException e) {
+            throw new NoLeaveGrantedException("Leave not sanctioned.", e);
+        }
+    }
+
+    private static void howIsTeamLead() throws TeamLeadUpsetException {
+        try {
+            howIsManager();
+        } catch (ManagerUpsetException e) {
+            throw new TeamLeadUpsetException("Team lead is not in good mood", e);
+        }
+    }
+
+    private static void howIsManager() throws ManagerUpsetException {
+        try {
+            howIsGirlFriendOfManager();
+        } catch (GirlFriendOfManagerUpsetException e) {
+            throw new ManagerUpsetException("Manager is in bad mood", e);
+        }
+    }
+
+    private static void howIsGirlFriendOfManager() throws GirlFriendOfManagerUpsetException {
+        throw new GirlFriendOfManagerUpsetException("Girl friend of manager is in bad mood");
+    }
+}

core-java/src/main/java/com/baeldung/chainedexception/LogWithoutChain.java

@@ -0,0 +1,44 @@
+package com.baeldung.chainedexception;
+
+import com.baeldung.chainedexception.exceptions.GirlFriendOfManagerUpsetException;
+import com.baeldung.chainedexception.exceptions.ManagerUpsetException;
+import com.baeldung.chainedexception.exceptions.NoLeaveGrantedException;
+import com.baeldung.chainedexception.exceptions.TeamLeadUpsetException;
+
+public class LogWithoutChain {
+
+    public static void main(String[] args) throws Exception {
+        getLeave();
+    }
+
+    private static void getLeave() throws NoLeaveGrantedException {
+        try {
+            howIsTeamLead();
+        } catch (TeamLeadUpsetException e) {
+            e.printStackTrace();
+            throw new NoLeaveGrantedException("Leave not sanctioned.");
+        }
+    }
+
+    private static void howIsTeamLead() throws TeamLeadUpsetException {
+        try {
+            howIsManager();
+        } catch (ManagerUpsetException e) {
+            e.printStackTrace();
+            throw new TeamLeadUpsetException("Team lead is not in good mood");
+        }
+    }
+
+    private static void howIsManager() throws ManagerUpsetException {
+        try {
+            howIsGirlFriendOfManager();
+        } catch (GirlFriendOfManagerUpsetException e) {
+            e.printStackTrace();
+            throw new ManagerUpsetException("Manager is in bad mood");
+        }
+    }
+
+    private static void howIsGirlFriendOfManager() throws GirlFriendOfManagerUpsetException {
+        throw new GirlFriendOfManagerUpsetException("Girl friend of manager is in bad mood");
+    }
+}

core-java/src/main/java/com/baeldung/chainedexception/exceptions/GirlFriendOfManagerUpsetException.java

@@ -0,0 +1,12 @@
+package com.baeldung.chainedexception.exceptions;
+
+public class GirlFriendOfManagerUpsetException extends Exception {
+
+    public GirlFriendOfManagerUpsetException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public GirlFriendOfManagerUpsetException(String message) {
+        super(message);
+    }
+}

core-java/src/main/java/com/baeldung/chainedexception/exceptions/ManagerUpsetException.java

@@ -0,0 +1,12 @@
+package com.baeldung.chainedexception.exceptions;
+
+public class ManagerUpsetException extends Exception {
+
+    public ManagerUpsetException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public ManagerUpsetException(String message) {
+        super(message);
+    }
+}

core-java/src/main/java/com/baeldung/chainedexception/exceptions/NoLeaveGrantedException.java

@@ -0,0 +1,12 @@
+package com.baeldung.chainedexception.exceptions;
+
+public class NoLeaveGrantedException extends Exception {
+
+    public NoLeaveGrantedException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public NoLeaveGrantedException(String message) {
+        super(message);
+    }
+}

core-java/src/main/java/com/baeldung/chainedexception/exceptions/TeamLeadUpsetException.java

@@ -0,0 +1,12 @@
+package com.baeldung.chainedexception.exceptions;
+
+public class TeamLeadUpsetException extends Exception {
+
+    public TeamLeadUpsetException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public TeamLeadUpsetException(String message) {
+        super(message);
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/blockingqueue/BlockingQueueUsage.java

@@ -0,0 +1,24 @@
+package com.baeldung.concurrent.blockingqueue;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+public class BlockingQueueUsage {
+    public static void main(String[] args) {
+        int BOUND = 10;
+        int N_PRODUCERS = 4;
+        int N_CONSUMERS = Runtime.getRuntime().availableProcessors();
+        int poisonPill = Integer.MAX_VALUE;
+        int poisonPillPerProducer = N_CONSUMERS / N_PRODUCERS;
+
+        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(BOUND);
+
+        for (int i = 0; i < N_PRODUCERS; i++) {
+            new Thread(new NumbersProducer(queue, poisonPill, poisonPillPerProducer)).start();
+        }
+
+        for (int j = 0; j < N_CONSUMERS; j++) {
+            new Thread(new NumbersConsumer(queue, poisonPill)).start();
+        }
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersConsumer.java

@@ -0,0 +1,28 @@
+package com.baeldung.concurrent.blockingqueue;
+
+import java.util.concurrent.BlockingQueue;
+
+public class NumbersConsumer implements Runnable {
+    private final BlockingQueue<Integer> queue;
+    private final int poisonPill;
+
+    public NumbersConsumer(BlockingQueue<Integer> queue, int poisonPill) {
+        this.queue = queue;
+        this.poisonPill = poisonPill;
+    }
+
+    public void run() {
+        try {
+            while (true) {
+                Integer number = queue.take();
+                if (number.equals(poisonPill)) {
+                    return;
+                }
+                String result = number.toString();
+                System.out.println(Thread.currentThread().getName() + " result: " + result);
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/blockingqueue/NumbersProducer.java

@@ -0,0 +1,34 @@
+package com.baeldung.concurrent.blockingqueue;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class NumbersProducer implements Runnable {
+
+    private final BlockingQueue<Integer> numbersQueue;
+    private final int poisonPill;
+    private final int poisonPillPerProducer;
+
+    public NumbersProducer(BlockingQueue<Integer> numbersQueue, int poisonPill, int poisonPillPerProducer) {
+        this.numbersQueue = numbersQueue;
+        this.poisonPill = poisonPill;
+        this.poisonPillPerProducer = poisonPillPerProducer;
+    }
+
+    public void run() {
+        try {
+            generateNumbers();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private void generateNumbers() throws InterruptedException {
+        for (int i = 0; i < 100; i++) {
+            numbersQueue.put(ThreadLocalRandom.current().nextInt(100));
+        }
+        for (int j = 0; j < poisonPillPerProducer; j++) {
+            numbersQueue.put(poisonPill);
+        }
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/countdownlatch/BrokenWorker.java

@@ -0,0 +1,23 @@
+package com.baeldung.concurrent.countdownlatch;
+
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+public class BrokenWorker implements Runnable {
+    private final List<String> outputScraper;
+    private final CountDownLatch countDownLatch;
+
+    public BrokenWorker(final List<String> outputScraper, final CountDownLatch countDownLatch) {
+        this.outputScraper = outputScraper;
+        this.countDownLatch = countDownLatch;
+    }
+
+    @Override
+    public void run() {
+        if (true) {
+            throw new RuntimeException("Oh dear");
+        }
+        countDownLatch.countDown();
+        outputScraper.add("Counted down");
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/countdownlatch/WaitingWorker.java

@@ -0,0 +1,34 @@
+package com.baeldung.concurrent.countdownlatch;
+
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+public class WaitingWorker implements Runnable {
+
+    private final List<String> outputScraper;
+    private final CountDownLatch readyThreadCounter;
+    private final CountDownLatch callingThreadBlocker;
+    private final CountDownLatch completedThreadCounter;
+
+    public WaitingWorker(final List<String> outputScraper, final CountDownLatch readyThreadCounter, final CountDownLatch callingThreadBlocker, CountDownLatch completedThreadCounter) {
+
+        this.outputScraper = outputScraper;
+        this.readyThreadCounter = readyThreadCounter;
+        this.callingThreadBlocker = callingThreadBlocker;
+        this.completedThreadCounter = completedThreadCounter;
+    }
+
+    @Override
+    public void run() {
+        // Mark this thread as read / started
+        readyThreadCounter.countDown();
+        try {
+            callingThreadBlocker.await();
+            outputScraper.add("Counted down");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            completedThreadCounter.countDown();
+        }
+    }
+}

core-java/src/main/java/com/baeldung/concurrent/countdownlatch/Worker.java

@@ -0,0 +1,22 @@
+package com.baeldung.concurrent.countdownlatch;
+
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+public class Worker implements Runnable {
+    private final List<String> outputScraper;
+    private final CountDownLatch countDownLatch;
+
+    public Worker(final List<String> outputScraper, final CountDownLatch countDownLatch) {
+        this.outputScraper = outputScraper;
+        this.countDownLatch = countDownLatch;
+    }
+
+    @Override
+    public void run() {
+        // Do some work
+        System.out.println("Doing some logic");
+        outputScraper.add("Counted down");
+        countDownLatch.countDown();
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.baeldung.concurrent.future;
+
+import java.util.concurrent.RecursiveTask;
+
+public class FactorialSquareCalculator extends RecursiveTask<Integer> {
+    private static final long serialVersionUID = 1L;
+
+    final private Integer n;
+
+    public FactorialSquareCalculator(Integer n) {
+        this.n = n;
+    }
+
+    @Override
+    protected Integer compute() {
+        if (n <= 1) {
+            return n;
+        }
+
+        FactorialSquareCalculator calculator = new FactorialSquareCalculator(n - 1);
+
+        calculator.fork();
+
+        return n * n + calculator.join();
+    }
+}

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

@@ -0,0 +1,20 @@
+package com.baeldung.concurrent.future;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+
+public class SquareCalculator {
+
+    private final ExecutorService executor;
+
+    public SquareCalculator(ExecutorService executor) {
+        this.executor = executor;
+    }
+
+    public Future<Integer> calculate(Integer input) {
+        return executor.submit(() -> {
+            Thread.sleep(1000);
+            return input * input;
+        });        
+    }
+}

core-java/src/main/java/com/baeldung/java/map/MyLinkedHashMap.java

@@ -11,12 +11,10 @@ public class MyLinkedHashMap<K, V> extends LinkedHashMap<K, V> {
     private static final long serialVersionUID = 1L;
     private static final int MAX_ENTRIES = 5;
 
-
     public MyLinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
         super(initialCapacity, loadFactor, accessOrder);
     }
 
-
     @Override
     protected boolean removeEldestEntry(Map.Entry eldest) {
         return size() > MAX_ENTRIES;

core-java/src/main/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappers.java

@@ -0,0 +1,57 @@
+package com.baeldung.java8.lambda.exceptions;
+
+import java.util.function.Consumer;
+
+public class LambdaExceptionWrappers {
+
+    public static Consumer<Integer> lambdaWrapper(Consumer<Integer> consumer) {
+        return i -> {
+            try {
+                consumer.accept(i);
+            } catch (ArithmeticException e) {
+                System.err.println("Arithmetic Exception occured : " + e.getMessage());
+            }
+        };
+    }
+
+    static <T, E extends Exception> Consumer<T> consumerWrapper(Consumer<T> consumer, Class<E> clazz) {
+        return i -> {
+            try {
+                consumer.accept(i);
+            } catch (Exception ex) {
+                try {
+                    E exCast = clazz.cast(ex);
+                    System.err.println("Exception occured : " + exCast.getMessage());
+                } catch (ClassCastException ccEx) {
+                    throw ex;
+                }
+            }
+        };
+    }
+
+    public static <T> Consumer<T> throwingConsumerWrapper(ThrowingConsumer<T, Exception> throwingConsumer) {
+        return i -> {
+            try {
+                throwingConsumer.accept(i);
+            } catch (Exception ex) {
+                throw new RuntimeException(ex);
+            }
+        };
+    }
+
+    public static <T, E extends Exception> Consumer<T> handlingConsumerWrapper(ThrowingConsumer<T, E> throwingConsumer, Class<E> exceptionClass) {
+        return i -> {
+            try {
+                throwingConsumer.accept(i);
+            } catch (Exception ex) {
+                try {
+                    E exCast = exceptionClass.cast(ex);
+                    System.err.println("Exception occured : " + exCast.getMessage());
+                } catch (ClassCastException ccEx) {
+                    throw new RuntimeException(ex);
+                }
+            }
+        };
+    }
+
+}

core-java/src/main/java/com/baeldung/java8/lambda/exceptions/ThrowingConsumer.java

@@ -0,0 +1,8 @@
+package com.baeldung.java8.lambda.exceptions;
+
+@FunctionalInterface
+public interface ThrowingConsumer<T, E extends Exception> {
+
+    void accept(T t) throws E;
+
+}

core-java/src/test/java/com/baeldung/CharArrayToStringUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class CharArrayToStringUnitTest {
+
+    @Test
+    public void givenCharArray_whenCallingStringConstructor_shouldConvertToString() {
+        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+        String result = new String(charArray);
+        String expectedValue = "character";
+        
+        assertEquals(expectedValue, result);
+    }
+    
+    @Test
+    public void givenCharArray_whenCallingStringConstructorWithOffsetAndLength_shouldConvertToString(){
+        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+        String result = new String(charArray, 4, 3);
+        String expectedValue = "act";
+        
+        assertEquals(expectedValue, result);
+    }
+    
+    @Test
+    public void givenCharArray_whenCallingStringCopyValueOf_shouldConvertToString(){
+        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+        String result = String.copyValueOf(charArray);
+        String expectedValue = "character";
+        
+        assertEquals(expectedValue, result);
+    }
+    
+    @Test
+    public void givenCharArray_whenCallingStringCopyValueOfWithOffsetAndLength_shouldConvertToString(){
+        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+        String result = String.copyValueOf(charArray, 0, 4);
+        String expectedValue = "char";
+        
+        assertEquals(expectedValue, result);
+    }
+    
+    @Test
+    public void givenCharArray_whenCallingStringValueOf_shouldConvertToString(){
+        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+        String result = String.valueOf(charArray);
+        String expectedValue = "character";
+        
+        assertEquals(expectedValue, result);
+    }
+    
+    @Test
+    public void givenCharArray_whenCallingStringValueOfWithOffsetAndLength_shouldConvertToString(){
+        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+        String result = String.valueOf(charArray, 3, 4);
+        String expectedValue = "ract";
+        
+        assertEquals(expectedValue, result);
+    }
+}

core-java/src/test/java/com/baeldung/StringToCharArrayUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class StringToCharArrayUnitTest {
+
+@Test
+public void givenString_whenCallingStringToCharArray_shouldConvertToCharArray() {
+    String givenString = "characters";
+
+    char[] result = givenString.toCharArray();
+
+    char[] expectedCharArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's' };
+
+    assertArrayEquals(expectedCharArray, result);
+}
+
+}

core-java/src/test/java/com/baeldung/collectors/Java8CollectorsUnitTest.java

@@ -42,116 +42,80 @@ public class Java8CollectorsUnitTest {
 
     @Test
     public void whenCollectingToList_shouldCollectToList() throws Exception {
-        final List<String> result = givenList
-          .stream()
-          .collect(toList());
+        final List<String> result = givenList.stream().collect(toList());
 
         assertThat(result).containsAll(givenList);
     }
 
     @Test
     public void whenCollectingToList_shouldCollectToSet() throws Exception {
-        final Set<String> result = givenList
-          .stream()
-          .collect(toSet());
+        final Set<String> result = givenList.stream().collect(toSet());
 
         assertThat(result).containsAll(givenList);
     }
 
     @Test
     public void whenCollectingToCollection_shouldCollectToCollection() throws Exception {
-        final List<String> result = givenList
-          .stream()
-          .collect(toCollection(LinkedList::new));
+        final List<String> result = givenList.stream().collect(toCollection(LinkedList::new));
 
-        assertThat(result)
-          .containsAll(givenList)
-          .isInstanceOf(LinkedList.class);
+        assertThat(result).containsAll(givenList).isInstanceOf(LinkedList.class);
     }
 
     @Test
     public void whenCollectingToImmutableCollection_shouldThrowException() throws Exception {
         assertThatThrownBy(() -> {
-            givenList
-              .stream()
-              .collect(toCollection(ImmutableList::of));
+            givenList.stream().collect(toCollection(ImmutableList::of));
         }).isInstanceOf(UnsupportedOperationException.class);
 
     }
 
     @Test
     public void whenCollectingToMap_shouldCollectToMap() throws Exception {
-        final Map<String, Integer> result = givenList
-          .stream()
-          .collect(toMap(Function.identity(), String::length));
+        final Map<String, Integer> result = givenList.stream().collect(toMap(Function.identity(), String::length));
 
-        assertThat(result)
-          .containsEntry("a", 1)
-          .containsEntry("bb", 2)
-          .containsEntry("ccc", 3)
-          .containsEntry("dd", 2);
+        assertThat(result).containsEntry("a", 1).containsEntry("bb", 2).containsEntry("ccc", 3).containsEntry("dd", 2);
     }
 
     @Test
     public void whenCollectingToMap_shouldCollectToMapMerging() throws Exception {
-        final Map<String, Integer> result = givenList
-          .stream()
-          .collect(toMap(Function.identity(), String::length, (i1, i2) -> i1));
+        final Map<String, Integer> result = givenList.stream().collect(toMap(Function.identity(), String::length, (i1, i2) -> i1));
 
-        assertThat(result)
-          .containsEntry("a", 1)
-          .containsEntry("bb", 2)
-          .containsEntry("ccc", 3)
-          .containsEntry("dd", 2);
+        assertThat(result).containsEntry("a", 1).containsEntry("bb", 2).containsEntry("ccc", 3).containsEntry("dd", 2);
     }
 
     @Test
     public void whenCollectingAndThen_shouldCollect() throws Exception {
-        final List<String> result = givenList
-          .stream()
-          .collect(collectingAndThen(toList(), ImmutableList::copyOf));
+        final List<String> result = givenList.stream().collect(collectingAndThen(toList(), ImmutableList::copyOf));
 
-        assertThat(result)
-          .containsAll(givenList)
-          .isInstanceOf(ImmutableList.class);
+        assertThat(result).containsAll(givenList).isInstanceOf(ImmutableList.class);
     }
 
     @Test
     public void whenJoining_shouldJoin() throws Exception {
-        final String result = givenList
-          .stream()
-          .collect(joining());
+        final String result = givenList.stream().collect(joining());
 
         assertThat(result).isEqualTo("abbcccdd");
     }
 
     @Test
     public void whenJoiningWithSeparator_shouldJoinWithSeparator() throws Exception {
-        final String result = givenList
-          .stream()
-          .collect(joining(" "));
+        final String result = givenList.stream().collect(joining(" "));
 
         assertThat(result).isEqualTo("a bb ccc dd");
     }
 
     @Test
     public void whenJoiningWithSeparatorAndPrefixAndPostfix_shouldJoinWithSeparatorPrePost() throws Exception {
-        final String result = givenList
-          .stream()
-          .collect(joining(" ", "PRE-", "-POST"));
+        final String result = givenList.stream().collect(joining(" ", "PRE-", "-POST"));
 
         assertThat(result).isEqualTo("PRE-a bb ccc dd-POST");
     }
 
     @Test
     public void whenPartitioningBy_shouldPartition() throws Exception {
-        final Map<Boolean, List<String>> result = givenList
-          .stream()
-          .collect(partitioningBy(s -> s.length() > 2));
+        final Map<Boolean, List<String>> result = givenList.stream().collect(partitioningBy(s -> s.length() > 2));
 
-        assertThat(result)
-          .containsKeys(true, false)
-          .satisfies(booleanListMap -> {
+        assertThat(result).containsKeys(true, false).satisfies(booleanListMap -> {
             assertThat(booleanListMap.get(true)).contains("ccc");
 
             assertThat(booleanListMap.get(false)).contains("a", "bb", "dd");
@@ -160,18 +124,14 @@ public class Java8CollectorsUnitTest {
 
     @Test
     public void whenCounting_shouldCount() throws Exception {
-        final Long result = givenList
-          .stream()
-          .collect(counting());
+        final Long result = givenList.stream().collect(counting());
 
         assertThat(result).isEqualTo(4);
     }
 
     @Test
     public void whenSummarizing_shouldSummarize() throws Exception {
-        final DoubleSummaryStatistics result = givenList
-          .stream()
-          .collect(summarizingDouble(String::length));
+        final DoubleSummaryStatistics result = givenList.stream().collect(summarizingDouble(String::length));
 
         assertThat(result.getAverage()).isEqualTo(2);
         assertThat(result.getCount()).isEqualTo(4);
@@ -182,55 +142,37 @@ public class Java8CollectorsUnitTest {
 
     @Test
     public void whenAveraging_shouldAverage() throws Exception {
-        final Double result = givenList
-          .stream()
-          .collect(averagingDouble(String::length));
+        final Double result = givenList.stream().collect(averagingDouble(String::length));
 
         assertThat(result).isEqualTo(2);
     }
 
     @Test
     public void whenSumming_shouldSum() throws Exception {
-        final Double result = givenList
-          .stream()
-          .filter(i -> true)
-          .collect(summingDouble(String::length));
+        final Double result = givenList.stream().filter(i -> true).collect(summingDouble(String::length));
 
         assertThat(result).isEqualTo(8);
     }
 
     @Test
     public void whenMaxingBy_shouldMaxBy() throws Exception {
-        final Optional<String> result = givenList
-          .stream()
-          .collect(maxBy(Comparator.naturalOrder()));
+        final Optional<String> result = givenList.stream().collect(maxBy(Comparator.naturalOrder()));
 
-        assertThat(result)
-          .isPresent()
-          .hasValue("dd");
+        assertThat(result).isPresent().hasValue("dd");
     }
 
     @Test
     public void whenGroupingBy_shouldGroupBy() throws Exception {
-        final Map<Integer, Set<String>> result = givenList
-          .stream()
-          .collect(groupingBy(String::length, toSet()));
+        final Map<Integer, Set<String>> result = givenList.stream().collect(groupingBy(String::length, toSet()));
 
-        assertThat(result)
-          .containsEntry(1, newHashSet("a"))
-          .containsEntry(2, newHashSet("bb", "dd"))
-          .containsEntry(3, newHashSet("ccc"));
+        assertThat(result).containsEntry(1, newHashSet("a")).containsEntry(2, newHashSet("bb", "dd")).containsEntry(3, newHashSet("ccc"));
     }
 
     @Test
     public void whenCreatingCustomCollector_shouldCollect() throws Exception {
-        final ImmutableSet<String> result = givenList
-          .stream()
-          .collect(toImmutableSet());
+        final ImmutableSet<String> result = givenList.stream().collect(toImmutableSet());
 
-        assertThat(result)
-          .isInstanceOf(ImmutableSet.class)
-          .contains("a", "bb", "ccc", "dd");
+        assertThat(result).isInstanceOf(ImmutableSet.class).contains("a", "bb", "ccc", "dd");
 
     }
 

core-java/src/test/java/com/baeldung/concurrent/countdownlatch/CountdownLatchExampleTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.concurrent.countdownlatch;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class CountdownLatchExampleTest {
+    @Test
+    public void whenParallelProcessing_thenMainThreadWillBlockUntilCompletion() throws InterruptedException {
+        // Given
+        List<String> outputScraper = Collections.synchronizedList(new ArrayList<>());
+        CountDownLatch countDownLatch = new CountDownLatch(5);
+        List<Thread> workers = Stream.generate(() -> new Thread(new Worker(outputScraper, countDownLatch))).limit(5).collect(toList());
+
+        // When
+        workers.forEach(Thread::start);
+        countDownLatch.await(); // Block until workers finish
+        outputScraper.add("Latch released");
+
+        // Then
+        outputScraper.forEach(Object::toString);
+        assertThat(outputScraper).containsExactly("Counted down", "Counted down", "Counted down", "Counted down", "Counted down", "Latch released");
+    }
+
+    @Test
+    public void whenFailingToParallelProcess_thenMainThreadShouldTimeout() throws InterruptedException {
+        // Given
+        List<String> outputScraper = Collections.synchronizedList(new ArrayList<>());
+        CountDownLatch countDownLatch = new CountDownLatch(5);
+        List<Thread> workers = Stream.generate(() -> new Thread(new BrokenWorker(outputScraper, countDownLatch))).limit(5).collect(toList());
+
+        // When
+        workers.forEach(Thread::start);
+        final boolean result = countDownLatch.await(3L, TimeUnit.SECONDS);
+
+        // Then
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void whenDoingLotsOfThreadsInParallel_thenStartThemAtTheSameTime() throws InterruptedException {
+        // Given
+        List<String> outputScraper = Collections.synchronizedList(new ArrayList<>());
+        CountDownLatch readyThreadCounter = new CountDownLatch(5);
+        CountDownLatch callingThreadBlocker = new CountDownLatch(1);
+        CountDownLatch completedThreadCounter = new CountDownLatch(5);
+        List<Thread> workers = Stream.generate(() -> new Thread(new WaitingWorker(outputScraper, readyThreadCounter, callingThreadBlocker, completedThreadCounter))).limit(5).collect(toList());
+
+        // When
+        workers.forEach(Thread::start);
+        readyThreadCounter.await(); // Block until workers start
+        outputScraper.add("Workers ready");
+        callingThreadBlocker.countDown(); // Start workers
+        completedThreadCounter.await(); // Block until workers finish
+        outputScraper.add("Workers complete");
+
+        // Then
+        outputScraper.forEach(Object::toString);
+        assertThat(outputScraper).containsExactly("Workers ready", "Counted down", "Counted down", "Counted down", "Counted down", "Counted down", "Workers complete");
+    }
+
+}

core-java/src/test/java/com/baeldung/concurrent/future/FactorialSquareCalculatorUnitTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.concurrent.future;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.ForkJoinPool;
+
+import org.junit.Test;
+
+public class FactorialSquareCalculatorUnitTest {
+
+    @Test
+    public void whenCalculatesFactorialSquare_thenReturnCorrectValue() {
+        ForkJoinPool forkJoinPool = new ForkJoinPool();
+
+        FactorialSquareCalculator calculator = new FactorialSquareCalculator(10);
+
+        forkJoinPool.execute(calculator);
+
+        assertEquals("The sum of the squares from 1 to 10 is 385", 385, calculator.join().intValue());
+    }
+
+}

core-java/src/test/java/com/baeldung/concurrent/future/SquareCalculatorUnitTest.java

@@ -0,0 +1,94 @@
+package com.baeldung.concurrent.future;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestName;
+
+public class SquareCalculatorUnitTest {
+
+    @Rule
+    public TestName name = new TestName();
+
+    private long start;
+
+    private SquareCalculator squareCalculator;
+
+    @Test
+    public void givenExecutorIsSingleThreaded_whenTwoExecutionsAreTriggered_thenRunInSequence() throws InterruptedException, ExecutionException {
+        squareCalculator = new SquareCalculator(Executors.newSingleThreadExecutor());
+
+        Future<Integer> result1 = squareCalculator.calculate(4);
+        Future<Integer> result2 = squareCalculator.calculate(1000);
+
+        while (!result1.isDone() || !result2.isDone()) {
+            System.out.println(String.format("Task 1 is %s and Task 2 is %s.", result1.isDone() ? "done" : "not done", result2.isDone() ? "done" : "not done"));
+
+            Thread.sleep(300);
+        }
+
+        assertEquals(16, result1.get().intValue());
+        assertEquals(1000000, result2.get().intValue());
+    }
+
+    @Test(expected = TimeoutException.class)
+    public void whenGetWithTimeoutLowerThanExecutionTime_thenThrowException() throws InterruptedException, ExecutionException, TimeoutException {
+        squareCalculator = new SquareCalculator(Executors.newSingleThreadExecutor());
+
+        Future<Integer> result = squareCalculator.calculate(4);
+
+        result.get(500, TimeUnit.MILLISECONDS);
+    }
+
+    @Test
+    public void givenExecutorIsMultiThreaded_whenTwoExecutionsAreTriggered_thenRunInParallel() throws InterruptedException, ExecutionException {
+        squareCalculator = new SquareCalculator(Executors.newFixedThreadPool(2));
+
+        Future<Integer> result1 = squareCalculator.calculate(4);
+        Future<Integer> result2 = squareCalculator.calculate(1000);
+
+        while (!result1.isDone() || !result2.isDone()) {
+            System.out.println(String.format("Task 1 is %s and Task 2 is %s.", result1.isDone() ? "done" : "not done", result2.isDone() ? "done" : "not done"));
+
+            Thread.sleep(300);
+        }
+
+        assertEquals(16, result1.get().intValue());
+        assertEquals(1000000, result2.get().intValue());
+    }
+
+    @Test(expected = CancellationException.class)
+    public void whenCancelFutureAndCallGet_thenThrowException() throws InterruptedException, ExecutionException, TimeoutException {
+        squareCalculator = new SquareCalculator(Executors.newSingleThreadExecutor());
+
+        Future<Integer> result = squareCalculator.calculate(4);
+
+        boolean canceled = result.cancel(true);
+
+        assertTrue("Future was canceled", canceled);
+        assertTrue("Future was canceled", result.isCancelled());
+
+        result.get();
+    }
+
+    @Before
+    public void start() {
+        start = System.currentTimeMillis();
+    }
+
+    @After
+    public void end() {
+        System.out.println(String.format("Test %s took %s ms \n", name.getMethodName(), System.currentTimeMillis() - start));
+    }
+}

core-java/src/test/java/com/baeldung/guava/GuavaBiMapTest.java

@@ -0,0 +1,120 @@
+package com.baeldung.guava;
+
+import static org.junit.Assert.*;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.EnumHashBiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.ImmutableBiMap;
+
+public class GuavaBiMapTest {
+    @Test
+    public void whenQueryByValue_returnsKey() {
+        final BiMap<String, String> capitalCountryBiMap = HashBiMap.create();
+        capitalCountryBiMap.put("New Delhi", "India");
+        capitalCountryBiMap.put("Washingon, D.C.", "USA");
+        capitalCountryBiMap.put("Moscow", "Russia");
+
+        final String countryCapitalName = capitalCountryBiMap.inverse().get("India");
+
+        assertEquals("New Delhi", countryCapitalName);
+    }
+
+    @Test
+    public void whenCreateBiMapFromExistingMap_returnsKey() {
+        final Map<String, String> capitalCountryMap = new HashMap<>();
+        capitalCountryMap.put("New Delhi", "India");
+        capitalCountryMap.put("Washingon, D.C.", "USA");
+        capitalCountryMap.put("Moscow", "Russia");
+        final BiMap<String, String> capitalCountryBiMap = HashBiMap.create(capitalCountryMap);
+
+        final String countryCapitalName = capitalCountryBiMap.inverse().get("India");
+
+        assertEquals("New Delhi", countryCapitalName);
+    }
+
+    @Test
+    public void whenQueryByKey_returnsValue() {
+        final BiMap<String, String> capitalCountryBiMap = HashBiMap.create();
+
+        capitalCountryBiMap.put("New Delhi", "India");
+        capitalCountryBiMap.put("Washingon, D.C.", "USA");
+        capitalCountryBiMap.put("Moscow", "Russia");
+
+        assertEquals("USA", capitalCountryBiMap.get("Washingon, D.C."));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void whenSameValueIsPresent_throwsException() {
+        final BiMap<String, String> capitalCountryBiMap = HashBiMap.create();
+
+        capitalCountryBiMap.put("New Delhi", "India");
+        capitalCountryBiMap.put("Washingon, D.C.", "USA");
+        capitalCountryBiMap.put("Moscow", "Russia");
+        capitalCountryBiMap.put("Trump", "USA");
+    }
+
+    @Test
+    public void givenSameValueIsPresent_whenForcePut_completesSuccessfully() {
+        final BiMap<String, String> capitalCountryBiMap = HashBiMap.create();
+
+        capitalCountryBiMap.put("New Delhi", "India");
+        capitalCountryBiMap.put("Washingon, D.C.", "USA");
+        capitalCountryBiMap.put("Moscow", "Russia");
+        capitalCountryBiMap.forcePut("Trump", "USA");
+
+        assertEquals("USA", capitalCountryBiMap.get("Trump"));
+        assertEquals("Trump", capitalCountryBiMap.inverse().get("USA"));
+    }
+
+    @Test
+    public void whenSameKeyIsPresent_replacesAlreadyPresent() {
+        final BiMap<String, String> capitalCountryBiMap = HashBiMap.create();
+
+        capitalCountryBiMap.put("New Delhi", "India");
+        capitalCountryBiMap.put("Washingon, D.C.", "USA");
+        capitalCountryBiMap.put("Moscow", "Russia");
+        capitalCountryBiMap.put("Washingon, D.C.", "HongKong");
+
+        assertEquals("HongKong", capitalCountryBiMap.get("Washingon, D.C."));
+    }
+
+    @Test
+    public void whenUsingImmutableBiMap_allowsPutSuccessfully() {
+        final BiMap<String, String> capitalCountryBiMap = new ImmutableBiMap.Builder<String, String>().put("New Delhi", "India").put("Washingon, D.C.", "USA").put("Moscow", "Russia").build();
+
+        assertEquals("USA", capitalCountryBiMap.get("Washingon, D.C."));
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void whenUsingImmutableBiMap_doesntAllowRemove() {
+        final BiMap<String, String> capitalCountryBiMap = new ImmutableBiMap.Builder<String, String>().put("New Delhi", "India").put("Washingon, D.C.", "USA").put("Moscow", "Russia").build();
+
+        capitalCountryBiMap.remove("New Delhi");
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void whenUsingImmutableBiMap_doesntAllowPut() {
+        final BiMap<String, String> capitalCountryBiMap = new ImmutableBiMap.Builder<String, String>().put("New Delhi", "India").put("Washingon, D.C.", "USA").put("Moscow", "Russia").build();
+
+        capitalCountryBiMap.put("New York", "USA");
+    }
+
+    private enum Operation {
+        ADD, SUBTRACT, MULTIPLY, DIVIDE
+    }
+
+    @Test
+    public void whenUsingEnumAsKeyInMap_replacesAlreadyPresent() {
+        final BiMap<Operation, String> operationStringBiMap = EnumHashBiMap.create(Operation.class);
+
+        operationStringBiMap.put(Operation.ADD, "Add");
+        operationStringBiMap.put(Operation.SUBTRACT, "Subtract");
+        operationStringBiMap.put(Operation.MULTIPLY, "Multiply");
+        operationStringBiMap.put(Operation.DIVIDE, "Divide");
+
+        assertEquals("Divide", operationStringBiMap.get(Operation.DIVIDE));
+    }
+}

core-java/src/test/java/com/baeldung/java/concurrentmap/ConcurrentMapAggregateStatusTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.java.concurrentmap;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+public class ConcurrentMapAggregateStatusTest {
+
+    private ExecutorService executorService;
+    private Map<String, Integer> concurrentMap;
+    private List<Integer> mapSizes;
+    private int MAX_SIZE = 100000;
+
+    @Before
+    public void init() {
+        executorService = Executors.newFixedThreadPool(2);
+        concurrentMap = new ConcurrentHashMap<>();
+        mapSizes = new ArrayList<>(MAX_SIZE);
+    }
+
+    @Test
+    public void givenConcurrentMap_whenSizeWithoutConcurrentUpdates_thenCorrect() throws InterruptedException {
+        Runnable collectMapSizes = () -> {
+            for (int i = 0; i < MAX_SIZE; i++) {
+                concurrentMap.put(String.valueOf(i), i);
+                mapSizes.add(concurrentMap.size());
+            }
+        };
+        Runnable retrieveMapData = () -> {
+            for (int i = 0; i < MAX_SIZE; i++) {
+                concurrentMap.get(String.valueOf(i));
+            }
+        };
+        executorService.execute(retrieveMapData);
+        executorService.execute(collectMapSizes);
+        executorService.shutdown();
+        executorService.awaitTermination(1, TimeUnit.MINUTES);
+
+        for (int i = 1; i <= MAX_SIZE; i++) {
+            assertEquals("map size should be consistently reliable", i, mapSizes.get(i - 1).intValue());
+        }
+        assertEquals(MAX_SIZE, concurrentMap.size());
+    }
+
+    @Test
+    public void givenConcurrentMap_whenUpdatingAndGetSize_thenError() throws InterruptedException {
+        Runnable collectMapSizes = () -> {
+            for (int i = 0; i < MAX_SIZE; i++) {
+                mapSizes.add(concurrentMap.size());
+            }
+        };
+        Runnable updateMapData = () -> {
+            for (int i = 0; i < MAX_SIZE; i++) {
+                concurrentMap.put(String.valueOf(i), i);
+            }
+        };
+        executorService.execute(updateMapData);
+        executorService.execute(collectMapSizes);
+        executorService.shutdown();
+        executorService.awaitTermination(1, TimeUnit.MINUTES);
+
+        assertNotEquals("map size collected with concurrent updates not reliable", MAX_SIZE, mapSizes.get(MAX_SIZE - 1).intValue());
+        assertEquals(MAX_SIZE, concurrentMap.size());
+    }
+
+}

core-java/src/test/java/com/baeldung/java/concurrentmap/ConcurrentMapNullKeyValueTest.java

@@ -0,0 +1,160 @@
+package com.baeldung.java.concurrentmap;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import static org.junit.Assert.assertNull;
+
+public class ConcurrentMapNullKeyValueTest {
+
+    ConcurrentMap<String, Object> concurrentMap;
+
+    @Before
+    public void setup() {
+        concurrentMap = new ConcurrentHashMap<>();
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenGetWithNullKey_thenThrowsNPE() {
+        concurrentMap.get(null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenGetOrDefaultWithNullKey_thenThrowsNPE() {
+        concurrentMap.getOrDefault(null, new Object());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenPutWithNullKey_thenThrowsNPE() {
+        concurrentMap.put(null, new Object());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenPutNullValue_thenThrowsNPE() {
+        concurrentMap.put("test", null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMapAndKeyAbsent_whenPutWithNullKey_thenThrowsNPE() {
+        concurrentMap.putIfAbsent(null, new Object());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMapAndMapWithNullKey_whenPutNullKeyMap_thenThrowsNPE() {
+        Map<String, Object> nullKeyMap = new HashMap<>();
+        nullKeyMap.put(null, new Object());
+        concurrentMap.putAll(nullKeyMap);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMapAndMapWithNullValue_whenPutNullValueMap_thenThrowsNPE() {
+        Map<String, Object> nullValueMap = new HashMap<>();
+        nullValueMap.put("test", null);
+        concurrentMap.putAll(nullValueMap);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenReplaceNullKeyWithValues_thenThrowsNPE() {
+        concurrentMap.replace(null, new Object(), new Object());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenReplaceWithNullNewValue_thenThrowsNPE() {
+        Object o = new Object();
+        concurrentMap.replace("test", o, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenReplaceOldNullValue_thenThrowsNPE() {
+        Object o = new Object();
+        concurrentMap.replace("test", null, o);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenReplaceWithNullValue_thenThrowsNPE() {
+        concurrentMap.replace("test", null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenReplaceNullKey_thenThrowsNPE() {
+        concurrentMap.replace(null, "test");
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenReplaceAllMappingNull_thenThrowsNPE() {
+        concurrentMap.put("test", new Object());
+        concurrentMap.replaceAll((s, o) -> null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenRemoveNullKey_thenThrowsNPE() {
+        concurrentMap.remove(null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenRemoveNullKeyWithValue_thenThrowsNPE() {
+        concurrentMap.remove(null, new Object());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenMergeNullKeyWithValue_thenThrowsNPE() {
+        concurrentMap.merge(null, new Object(), (o, o2) -> o2);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenMergeKeyWithNullValue_thenThrowsNPE() {
+        concurrentMap.put("test", new Object());
+        concurrentMap.merge("test", null, (o, o2) -> o2);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMapAndAssumeKeyAbsent_whenComputeWithNullKey_thenThrowsNPE() {
+        concurrentMap.computeIfAbsent(null, s -> s);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMapAndAssumeKeyPresent_whenComputeWithNullKey_thenThrowsNPE() {
+        concurrentMap.computeIfPresent(null, (s, o) -> o);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenConcurrentHashMap_whenComputeWithNullKey_thenThrowsNPE() {
+        concurrentMap.compute(null, (s, o) -> o);
+    }
+
+    @Test
+    public void givenConcurrentHashMap_whenMergeKeyRemappingNull_thenRemovesMapping() {
+        Object oldValue = new Object();
+        concurrentMap.put("test", oldValue);
+        concurrentMap.merge("test", new Object(), (o, o2) -> null);
+        assertNull(concurrentMap.get("test"));
+    }
+
+    @Test
+    public void givenConcurrentHashMapAndKeyAbsent_whenComputeWithKeyRemappingNull_thenRemainsAbsent() {
+        concurrentMap.computeIfPresent("test", (s, o) -> null);
+        assertNull(concurrentMap.get("test"));
+    }
+
+    @Test
+    public void givenKeyPresent_whenComputeIfPresentRemappingNull_thenMappingRemoved() {
+        Object oldValue = new Object();
+        concurrentMap.put("test", oldValue);
+        concurrentMap.computeIfPresent("test", (s, o) -> null);
+        assertNull(concurrentMap.get("test"));
+    }
+
+    @Test
+    public void givenKeyPresent_whenComputeRemappingNull_thenMappingRemoved() {
+        Object oldValue = new Object();
+        concurrentMap.put("test", oldValue);
+        concurrentMap.compute("test", (s, o) -> null);
+        assertNull(concurrentMap.get("test"));
+    }
+
+}

core-java/src/test/java/com/baeldung/java/concurrentmap/ConcurrentMapPerformanceTest.java

@@ -0,0 +1,95 @@
+package com.baeldung.java.concurrentmap;
+
+import org.junit.Test;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Map;
+import java.util.concurrent.*;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class ConcurrentMapPerformanceTest {
+
+    @Test
+    public void givenMaps_whenGetPut500KTimes_thenConcurrentMapFaster() throws Exception {
+        Map<String, Object> hashtable = new Hashtable<>();
+        Map<String, Object> synchronizedHashMap = Collections.synchronizedMap(new HashMap<>());
+        Map<String, Object> concurrentHashMap = new ConcurrentHashMap<>();
+
+        long hashtableAvgRuntime = timeElapseForGetPut(hashtable);
+        long syncHashMapAvgRuntime = timeElapseForGetPut(synchronizedHashMap);
+        long concurrentHashMapAvgRuntime = timeElapseForGetPut(concurrentHashMap);
+
+        System.out.println(String.format("Hashtable: %s, syncHashMap: %s, ConcurrentHashMap: %s", hashtableAvgRuntime, syncHashMapAvgRuntime, concurrentHashMapAvgRuntime));
+
+        assertTrue(hashtableAvgRuntime > concurrentHashMapAvgRuntime);
+        assertTrue(syncHashMapAvgRuntime > concurrentHashMapAvgRuntime);
+
+    }
+
+    private long timeElapseForGetPut(Map<String, Object> map) throws InterruptedException {
+        ExecutorService executorService = Executors.newFixedThreadPool(4);
+        long startTime = System.nanoTime();
+        for (int i = 0; i < 4; i++) {
+            executorService.execute(() -> {
+                for (int j = 0; j < 500_000; j++) {
+                    int value = ThreadLocalRandom.current().nextInt(10000);
+                    String key = String.valueOf(value);
+                    map.put(key, value);
+                    map.get(key);
+                }
+            });
+        }
+        executorService.shutdown();
+        executorService.awaitTermination(1, TimeUnit.MINUTES);
+        return (System.nanoTime() - startTime) / 500_000;
+    }
+
+    @Test
+    public void givenConcurrentMap_whenKeyWithSameHashCode_thenPerformanceDegrades() throws InterruptedException {
+        class SameHash {
+            @Override
+            public int hashCode() {
+                return 1;
+            }
+        }
+        int executeTimes = 5000;
+
+        Map<SameHash, Integer> mapOfSameHash = new ConcurrentHashMap<>();
+        ExecutorService executorService = Executors.newFixedThreadPool(2);
+        long sameHashStartTime = System.currentTimeMillis();
+        for (int i = 0; i < 2; i++) {
+            executorService.execute(() -> {
+                for (int j = 0; j < executeTimes; j++) {
+                    mapOfSameHash.put(new SameHash(), 1);
+                }
+            });
+        }
+        executorService.shutdown();
+        executorService.awaitTermination(5, TimeUnit.SECONDS);
+
+        long mapOfSameHashDuration = System.currentTimeMillis() - sameHashStartTime;
+        Map<Object, Integer> mapOfDefaultHash = new ConcurrentHashMap<>();
+        executorService = Executors.newFixedThreadPool(2);
+        long defaultHashStartTime = System.currentTimeMillis();
+        for (int i = 0; i < 2; i++) {
+            executorService.execute(() -> {
+                for (int j = 0; j < executeTimes; j++) {
+                    mapOfDefaultHash.put(new Object(), 1);
+                }
+            });
+        }
+        executorService.shutdown();
+        executorService.awaitTermination(5, TimeUnit.SECONDS);
+
+        long mapOfDefaultHashDuration = System.currentTimeMillis() - defaultHashStartTime;
+        assertEquals(executeTimes * 2, mapOfDefaultHash.size());
+        assertEquals(executeTimes * 2, mapOfSameHash.size());
+        System.out.println(String.format("same-hash: %s, default-hash: %s", mapOfSameHashDuration, mapOfDefaultHashDuration));
+        assertTrue("same hashCode() should greatly degrade performance", mapOfSameHashDuration > mapOfDefaultHashDuration * 10);
+    }
+
+}

core-java/src/test/java/com/baeldung/java/concurrentmap/ConcurrentNavigableMapTests.java

@@ -0,0 +1,79 @@
+package com.baeldung.java.concurrentmap;
+
+import org.junit.Test;
+
+import java.util.Iterator;
+import java.util.NavigableMap;
+import java.util.TreeMap;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.testng.Assert.*;
+
+public class ConcurrentNavigableMapTests {
+
+    @Test
+    public void givenSkipListMap_whenAccessInMultiThreads_thenOrderingStable() throws InterruptedException {
+        NavigableMap<Integer, String> skipListMap = new ConcurrentSkipListMap<>();
+
+        updateMapConcurrently(skipListMap, 4);
+
+        Iterator<Integer> skipListIter = skipListMap
+          .keySet()
+          .iterator();
+        int previous = skipListIter.next();
+        while (skipListIter.hasNext()) {
+            int current = skipListIter.next();
+            assertTrue(previous < current);
+        }
+    }
+
+    private void updateMapConcurrently(NavigableMap<Integer, String> navigableMap, int concurrencyLevel) throws InterruptedException {
+        ExecutorService executorService = Executors.newFixedThreadPool(concurrencyLevel);
+        for (int i = 0; i < concurrencyLevel; i++) {
+            executorService.execute(() -> {
+                ThreadLocalRandom random = ThreadLocalRandom.current();
+                for (int j = 0; j < 10000; j++) {
+                    navigableMap.put(random.nextInt(), "test");
+                }
+            });
+        }
+        executorService.shutdown();
+        executorService.awaitTermination(1, TimeUnit.MINUTES);
+    }
+
+    @Test
+    public void givenSkipListMap_whenNavConcurrently_thenCountCorrect() throws InterruptedException {
+        NavigableMap<Integer, Integer> skipListMap = new ConcurrentSkipListMap<>();
+        int count = countMapElementByPollingFirstEntry(skipListMap, 10000, 4);
+        assertEquals(10000 * 4, count);
+    }
+
+    @Test
+    public void givenTreeMap_whenNavConcurrently_thenCountError() throws InterruptedException {
+        NavigableMap<Integer, Integer> treeMap = new TreeMap<>();
+        int count = countMapElementByPollingFirstEntry(treeMap, 10000, 4);
+        assertNotEquals(10000 * 4, count);
+    }
+
+    private int countMapElementByPollingFirstEntry(NavigableMap<Integer, Integer> navigableMap, int elementCount, int concurrencyLevel) throws InterruptedException {
+        for (int i = 0; i < elementCount * concurrencyLevel; i++) {
+            navigableMap.put(i, i);
+        }
+        AtomicInteger counter = new AtomicInteger(0);
+        ExecutorService executorService = Executors.newFixedThreadPool(concurrencyLevel);
+        for (int j = 0; j < concurrencyLevel; j++) {
+            executorService.execute(() -> {
+                for (int i = 0; i < elementCount; i++) {
+                    if (navigableMap.pollFirstEntry() != null) {
+                        counter.incrementAndGet();
+                    }
+                }
+            });
+        }
+        executorService.shutdown();
+        executorService.awaitTermination(1, TimeUnit.MINUTES);
+        return counter.get();
+    }
+
+}

core-java/src/test/java/com/baeldung/java/concurrentmap/ConcurretMapMemoryConsistencyTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.java.concurrentmap;
+
+import org.junit.Test;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.*;
+
+public class ConcurretMapMemoryConsistencyTest {
+
+    @Test
+    public void givenConcurrentMap_whenSumParallel_thenCorrect() throws Exception {
+        Map<String, Integer> map = new ConcurrentHashMap<>();
+        List<Integer> sumList = parallelSum100(map, 1000);
+        assertEquals(1, sumList.stream().distinct().count());
+        long wrongResultCount = sumList.stream().filter(num -> num != 100).count();
+        assertEquals(0, wrongResultCount);
+    }
+
+    @Test
+    public void givenHashtable_whenSumParallel_thenCorrect() throws Exception {
+        Map<String, Integer> map = new Hashtable<>();
+        List<Integer> sumList = parallelSum100(map, 1000);
+        assertEquals(1, sumList.stream().distinct().count());
+        long wrongResultCount = sumList.stream().filter(num -> num != 100).count();
+        assertEquals(0, wrongResultCount);
+    }
+
+    @Test
+    public void givenHashMap_whenSumParallel_thenError() throws Exception {
+        Map<String, Integer> map = new HashMap<>();
+        List<Integer> sumList = parallelSum100(map, 100);
+        assertNotEquals(1, sumList.stream().distinct().count());
+        long wrongResultCount = sumList.stream().filter(num -> num != 100).count();
+        assertTrue(wrongResultCount > 0);
+    }
+
+    private List<Integer> parallelSum100(Map<String, Integer> map, int executionTimes) throws InterruptedException {
+        List<Integer> sumList = new ArrayList<>(1000);
+        for (int i = 0; i < executionTimes; i++) {
+            map.put("test", 0);
+            ExecutorService executorService = Executors.newFixedThreadPool(4);
+            for (int j = 0; j < 10; j++) {
+                executorService.execute(() -> {
+                    for (int k = 0; k < 10; k++)
+                        map.computeIfPresent("test", (key, value) -> value + 1);
+                });
+            }
+            executorService.shutdown();
+            executorService.awaitTermination(5, TimeUnit.SECONDS);
+            sumList.add(map.get("test"));
+        }
+        return sumList;
+    }
+
+}

core-java/src/test/java/com/baeldung/java/conversion/IterableStreamConversionTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.java.conversion;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+
+public class IterableStreamConversionTest {
+
+    @Test
+    public void givenIterable_whenConvertedToStream_thenNotNull() {
+        Iterable<String> iterable = Arrays.asList("Testing", "Iterable", "conversion", "to", "Stream");
+
+        Assert.assertNotNull(StreamSupport.stream(iterable.spliterator(), false));
+    }
+
+    @Test
+    public void whenConvertedToList_thenCorrect() {
+        Iterable<String> iterable = Arrays.asList("Testing", "Iterable", "conversion", "to", "Stream");
+
+        List<String> result = StreamSupport.stream(iterable.spliterator(), false).map(String::toUpperCase).collect(Collectors.toList());
+
+        assertThat(result, contains("TESTING", "ITERABLE", "CONVERSION", "TO", "STREAM"));
+    }
+}

core-java/src/test/java/com/baeldung/java/map/MapTest.java

@@ -201,8 +201,6 @@ public class MapTest {
         assertEquals("val1", rtnVal);
     }
 
-
-
     @Test
     public void whenCallsEqualsOnCollision_thenCorrect() {
         HashMap<MyKey, String> map = new HashMap<>();
@@ -311,13 +309,7 @@ public class MapTest {
 
     @Test
     public void givenTreeMap_whenOrdersEntriesByComparator_thenCorrect() {
-        TreeMap<Integer, String> map = new TreeMap<>(new Comparator<Integer>() {
-
-            @Override
-            public int compare(Integer o1, Integer o2) {
-                return o2 - o1;
-            }
-        });
+        TreeMap<Integer, String> map = new TreeMap<>(Comparator.reverseOrder());
         map.put(3, "val");
         map.put(2, "val");
         map.put(1, "val");

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

@@ -0,0 +1,46 @@
+package com.baeldung.java8;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import static org.hamcrest.Matchers.anyOf;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+public class Java8FindAnyFindFirstTest {
+
+    @Test
+    public void createStream_whenFindAnyResultIsPresent_thenCorrect() {
+
+        List<String> list = Arrays.asList("A", "B", "C", "D");
+
+        Optional<String> result = list.stream().findAny();
+
+        assertTrue(result.isPresent());
+        assertThat(result.get(), anyOf(is("A"), is("B"), is("C"), is("D")));
+    }
+
+    @Test
+    public void createParallelStream_whenFindAnyResultIsPresent_thenCorrect() throws Exception {
+        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
+        Optional<Integer> result = list.stream().parallel().filter(num -> num < 4).findAny();
+
+        assertTrue(result.isPresent());
+        assertThat(result.get(), anyOf(is(1), is(2), is(3)));
+    }
+
+    @Test
+    public void createStream_whenFindFirstResultIsPresent_thenCorrect() {
+
+        List<String> list = Arrays.asList("A", "B", "C", "D");
+
+        Optional<String> result = list.stream().findFirst();
+
+        assertTrue(result.isPresent());
+        assertThat(result.get(), is("A"));
+    }
+}

core-java/src/test/java/com/baeldung/java8/lambda/exceptions/LambdaExceptionWrappersTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.java8.lambda.exceptions;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+import static com.baeldung.java8.lambda.exceptions.LambdaExceptionWrappers.*;
+
+public class LambdaExceptionWrappersTest {
+
+    private List<Integer> integers;
+
+    @Before
+    public void init() {
+        integers = Arrays.asList(3, 9, 7, 0, 10, 20);
+    }
+
+    @Test
+    public void whenNoExceptionFromLambdaWrapper_thenSuccess() {
+        integers.forEach(lambdaWrapper(i -> System.out.println(50 / i)));
+    }
+
+    @Test
+    public void whenNoExceptionFromConsumerWrapper_thenSuccess() {
+        integers.forEach(consumerWrapper(i -> System.out.println(50 / i), ArithmeticException.class));
+    }
+
+    @Test(expected = RuntimeException.class)
+    public void whenExceptionFromThrowingConsumerWrapper_thenSuccess() {
+        integers.forEach(throwingConsumerWrapper(i -> writeToFile(i)));
+    }
+
+    @Test
+    public void whenNoExceptionFromHandlingConsumerWrapper_thenSuccess() {
+        integers.forEach(handlingConsumerWrapper(i -> writeToFile(i), IOException.class));
+    }
+
+    private void writeToFile(Integer i) throws IOException {
+        if (i == 0) {
+            throw new IOException(); // mock IOException
+        }
+    }
+}

core-java/src/test/java/com/baeldung/scripting/NashornTest.java

@@ -56,9 +56,7 @@ public class NashornTest {
         Map<String, Object> map = (Map<String, Object>) obj;
 
         Assert.assertEquals("hello", map.get("greet"));
-        Assert.assertTrue(List.class.isAssignableFrom(map
-          .get("primes")
-          .getClass()));
+        Assert.assertTrue(List.class.isAssignableFrom(map.get("primes").getClass()));
     }
 
     @Test

core-java/src/test/java/org/baeldung/java/collections/README.md

@@ -1,2 +1,3 @@
 ### Relevant Articles:
 - [Join and Split Arrays and Collections in Java](http://www.baeldung.com/java-join-and-split)
+- [Introduction to Java Servlets](http://www.baeldung.com/intro-to-servlets)

core-java/src/test/java/org/baeldung/java/io/JavaInputStreamToXUnitTest.java

@@ -1,38 +1,26 @@
 package org.baeldung.java.io;
 
-import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-
-import java.io.BufferedReader;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.io.Reader;
-import java.io.StringWriter;
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.StandardCopyOption;
-import java.util.Scanner;
-
-import org.apache.commons.io.FileUtils;
-import org.apache.commons.io.IOUtils;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.google.common.base.Charsets;
 import com.google.common.io.ByteSource;
 import com.google.common.io.ByteStreams;
 import com.google.common.io.CharStreams;
 import com.google.common.io.Files;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.IOUtils;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.StandardCopyOption;
+import java.util.Scanner;
+
+import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
 
 @SuppressWarnings("unused")
 public class JavaInputStreamToXUnitTest {
@@ -163,7 +151,7 @@ public class JavaInputStreamToXUnitTest {
     // tests - InputStream to File
 
     @Test
-    public final void givenUsingPlainJava_whenConvertingAnFullInputStreamToAFile_thenCorrect() throws IOException {
+    public final void whenConvertingToFile_thenCorrect() throws IOException {
         final InputStream initialStream = new FileInputStream(new File("src/main/resources/sample.txt"));
         final byte[] buffer = new byte[initialStream.available()];
         initialStream.read(buffer);
@@ -177,7 +165,7 @@ public class JavaInputStreamToXUnitTest {
     }
 
     @Test
-    public final void givenUsingPlainJava_whenConvertingAnInProgressInputStreamToAFile_thenCorrect() throws IOException {
+    public final void whenConvertingInProgressToFile_thenCorrect() throws IOException {
         final InputStream initialStream = new FileInputStream(new File("src/main/resources/sample.txt"));
         final File targetFile = new File("src/main/resources/targetFile.tmp");
         final OutputStream outStream = new FileOutputStream(targetFile);
@@ -193,7 +181,7 @@ public class JavaInputStreamToXUnitTest {
     }
 
     @Test
-    public final void givenUsingPlainJava8_whenConvertingAnInProgressInputStreamToAFile_thenCorrect() throws IOException {
+    public final void whenConvertingAnInProgressInputStreamToFile_thenCorrect2() throws IOException {
         final InputStream initialStream = new FileInputStream(new File("src/main/resources/sample.txt"));
         final File targetFile = new File("src/main/resources/targetFile.tmp");
 
@@ -203,7 +191,7 @@ public class JavaInputStreamToXUnitTest {
     }
 
     @Test
-    public final void givenUsingGuava_whenConvertingAnInputStreamToAFile_thenCorrect() throws IOException {
+    public final void whenConvertingInputStreamToFile_thenCorrect3() throws IOException {
         final InputStream initialStream = new FileInputStream(new File("src/main/resources/sample.txt"));
         final byte[] buffer = new byte[initialStream.available()];
         initialStream.read(buffer);
@@ -215,7 +203,7 @@ public class JavaInputStreamToXUnitTest {
     }
 
     @Test
-    public final void givenUsingCommonsIO_whenConvertingAnInputStreamToAFile_thenCorrect() throws IOException {
+    public final void whenConvertingInputStreamToFile_thenCorrect4() throws IOException {
         final InputStream initialStream = FileUtils.openInputStream(new File("src/main/resources/sample.txt"));
 
         final File targetFile = new File("src/main/resources/targetFile.tmp");

core-java/src/test/java/org/baeldung/java/streams/ThreadPoolInParallelStream.java

@@ -0,0 +1,45 @@
+package org.baeldung.java.streams;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ForkJoinPool;
+import java.util.stream.Stream;
+
+import org.junit.Test;
+
+public class ThreadPoolInParallelStream {
+    
+    @Test
+    public void giveRangeOfLongs_whenSummedInParallel_shouldBeEqualToExpectedTotal() 
+        throws InterruptedException, ExecutionException {
+        List<Long> aList = new ArrayList<>();        
+        long lastNum = 1_000_000;    
+        long firstNum = 1;
+        
+        long expectedTotal = (lastNum + firstNum) * lastNum / 2;
+        
+        for(long i = firstNum; i <= lastNum; i++){
+            aList.add(i);
+        } 
+        
+        ForkJoinPool customThreadPool = new ForkJoinPool(4);
+        long actualTotal = customThreadPool.submit(() -> aList.parallelStream().reduce(
+            0L, (x, y) -> { 
+                return x + y;
+            })).get();
+        
+        assertEquals(expectedTotal, actualTotal);
+    }
+    
+    @Test
+    public void givenList_whenCallingParallelStream_shouldBeParallelStream(){
+        List<Long> aList = new ArrayList<>();
+        Stream<Long> parallelStream = aList.parallelStream();
+        
+        assertTrue(parallelStream.isParallel());
+    }
+}

couchbase-sdk/src/main/java/com/baeldung/couchbase/async/person/Person.java

@@ -9,7 +9,8 @@ public class Person implements CouchbaseEntity {
     private String name;
     private String homeTown;
 
-    Person() {}
+    Person() {
+    }
 
     public Person(Builder b) {
         this.id = b.id;

couchbase-sdk/src/main/java/com/baeldung/couchbase/async/person/PersonCrudService.java

@@ -13,9 +13,7 @@ import com.baeldung.couchbase.async.service.BucketService;
 public class PersonCrudService extends AbstractCrudService<Person> {
 
     @Autowired
-    public PersonCrudService(
-      @Qualifier("TutorialBucketService") BucketService bucketService,
-      PersonDocumentConverter converter) {
+    public PersonCrudService(@Qualifier("TutorialBucketService") BucketService bucketService, PersonDocumentConverter converter) {
         super(bucketService, converter);
     }
 

couchbase-sdk/src/main/java/com/baeldung/couchbase/async/person/PersonDocumentConverter.java

@@ -11,10 +11,7 @@ public class PersonDocumentConverter implements JsonDocumentConverter<Person> {
 
     @Override
     public JsonDocument toDocument(Person p) {
-        JsonObject content = JsonObject.empty()
-                .put("type", "Person")
-                .put("name", p.getName())
-                .put("homeTown", p.getHomeTown());
+        JsonObject content = JsonObject.empty().put("type", "Person").put("name", p.getName()).put("homeTown", p.getHomeTown());
         return JsonDocument.create(p.getId(), content);
     }
 

couchbase-sdk/src/main/java/com/baeldung/couchbase/async/person/RegistrationService.java

@@ -19,10 +19,9 @@ public class RegistrationService {
     }
 
     public Person findRegistrant(String id) {
-        try{
+        try {
             return crud.read(id);
-        }
-        catch(CouchbaseException e) {
+        } catch (CouchbaseException e) {
             return crud.readFromReplica(id);
         }
     }

couchbase-sdk/src/main/java/com/baeldung/couchbase/async/service/AbstractBucketService.java

@@ -24,4 +24,4 @@ public abstract class AbstractBucketService implements BucketService {
     public Bucket getBucket() {
         return bucket;
     }
- }
+}

couchbase-sdk/src/main/java/com/baeldung/couchbase/async/service/AbstractCrudService.java

@@ -40,7 +40,7 @@ public abstract class AbstractCrudService<T extends CouchbaseEntity> implements
 
     @Override
     public void create(T t) {
-        if(t.getId() == null) {
+        if (t.getId() == null) {
             t.setId(UUID.randomUUID().toString());
         }
         JsonDocument doc = converter.toDocument(t);
@@ -73,9 +73,7 @@ public abstract class AbstractCrudService<T extends CouchbaseEntity> implements
     @Override
     public List<T> readBulk(Iterable<String> ids) {
         final AsyncBucket asyncBucket = bucket.async();
-        Observable<JsonDocument> asyncOperation = Observable
-                .from(ids)
-                .flatMap(new Func1<String, Observable<JsonDocument>>() {
+        Observable<JsonDocument> asyncOperation = Observable.from(ids).flatMap(new Func1<String, Observable<JsonDocument>>() {
             public Observable<JsonDocument> call(String key) {
                 return asyncBucket.get(key);
             }
@@ -83,8 +81,7 @@ public abstract class AbstractCrudService<T extends CouchbaseEntity> implements
 
         final List<T> items = new ArrayList<T>();
         try {
-            asyncOperation.toBlocking()
-            .forEach(new Action1<JsonDocument>() {
+            asyncOperation.toBlocking().forEach(new Action1<JsonDocument>() {
                 public void call(JsonDocument doc) {
                     T item = converter.fromDocument(doc);
                     items.add(item);
@@ -100,72 +97,42 @@ public abstract class AbstractCrudService<T extends CouchbaseEntity> implements
     @Override
     public void createBulk(Iterable<T> items) {
         final AsyncBucket asyncBucket = bucket.async();
-        Observable
-        .from(items)
-        .flatMap(new Func1<T, Observable<JsonDocument>>() {
+        Observable.from(items).flatMap(new Func1<T, Observable<JsonDocument>>() {
             @SuppressWarnings("unchecked")
             @Override
             public Observable<JsonDocument> call(final T t) {
-                if(t.getId() == null) {
+                if (t.getId() == null) {
                     t.setId(UUID.randomUUID().toString());
                 }
                 JsonDocument doc = converter.toDocument(t);
-                return asyncBucket.insert(doc)
-                        .retryWhen(RetryBuilder
-                                .anyOf(BackpressureException.class)
-                                .delay(Delay.exponential(TimeUnit.MILLISECONDS, 100))
-                                .max(10)
-                                .build());
+                return asyncBucket.insert(doc).retryWhen(RetryBuilder.anyOf(BackpressureException.class).delay(Delay.exponential(TimeUnit.MILLISECONDS, 100)).max(10).build());
             }
-        })
-        .last()
-        .toBlocking()
-        .single();
+        }).last().toBlocking().single();
     }
 
     @Override
     public void updateBulk(Iterable<T> items) {
         final AsyncBucket asyncBucket = bucket.async();
-        Observable
-        .from(items)
-        .flatMap(new Func1<T, Observable<JsonDocument>>() {
+        Observable.from(items).flatMap(new Func1<T, Observable<JsonDocument>>() {
             @SuppressWarnings("unchecked")
             @Override
             public Observable<JsonDocument> call(final T t) {
                 JsonDocument doc = converter.toDocument(t);
-                return asyncBucket.upsert(doc)
-                        .retryWhen(RetryBuilder
-                                .anyOf(BackpressureException.class)
-                                .delay(Delay.exponential(TimeUnit.MILLISECONDS, 100))
-                                .max(10)
-                                .build());
+                return asyncBucket.upsert(doc).retryWhen(RetryBuilder.anyOf(BackpressureException.class).delay(Delay.exponential(TimeUnit.MILLISECONDS, 100)).max(10).build());
             }
-        })
-        .last()
-        .toBlocking()
-        .single();
+        }).last().toBlocking().single();
     }
 
     @Override
     public void deleteBulk(Iterable<String> ids) {
         final AsyncBucket asyncBucket = bucket.async();
-        Observable
-        .from(ids)
-        .flatMap(new Func1<String, Observable<JsonDocument>>() {
+        Observable.from(ids).flatMap(new Func1<String, Observable<JsonDocument>>() {
             @SuppressWarnings("unchecked")
             @Override
             public Observable<JsonDocument> call(String key) {
-                return asyncBucket.remove(key)
-                        .retryWhen(RetryBuilder
-                                .anyOf(BackpressureException.class)
-                                .delay(Delay.exponential(TimeUnit.MILLISECONDS, 100))
-                                .max(10)
-                                .build());
+                return asyncBucket.remove(key).retryWhen(RetryBuilder.anyOf(BackpressureException.class).delay(Delay.exponential(TimeUnit.MILLISECONDS, 100)).max(10).build());
             }
-        })
-        .last()
-        .toBlocking()
-        .single();
+        }).last().toBlocking().single();
     }
 
     @Override

couchbase-sdk/src/main/java/com/baeldung/couchbase/async/service/ClusterServiceImpl.java

@@ -27,7 +27,7 @@ public class ClusterServiceImpl implements ClusterService {
 
     @Override
     synchronized public Bucket openBucket(String name, String password) {
-        if(!buckets.containsKey(name)) {
+        if (!buckets.containsKey(name)) {
             Bucket bucket = cluster.openBucket(name, password);
             buckets.put(name, bucket);
         }

couchbase-sdk/src/main/java/com/baeldung/couchbase/intro/CodeSnippets.java

@@ -20,10 +20,7 @@ public class CodeSnippets {
     }
 
     static Cluster loadClusterWithCustomEnvironment() {
-        CouchbaseEnvironment env = DefaultCouchbaseEnvironment.builder()
-                .connectTimeout(10000)
-                .kvTimeout(3000)
-                .build();        
+        CouchbaseEnvironment env = DefaultCouchbaseEnvironment.builder().connectTimeout(10000).kvTimeout(3000).build();
         return CouchbaseCluster.create(env, "localhost");
     }
 
@@ -36,12 +33,7 @@ public class CodeSnippets {
     }
 
     static JsonDocument insertExample(Bucket bucket) {
-        JsonObject content = JsonObject.empty()
-                .put("name", "John Doe")
-                .put("type", "Person")
-                .put("email", "john.doe@mydomain.com")
-                .put("homeTown", "Chicago")
-                ;
+        JsonObject content = JsonObject.empty().put("name", "John Doe").put("type", "Person").put("email", "john.doe@mydomain.com").put("homeTown", "Chicago");
         String id = UUID.randomUUID().toString();
         JsonDocument document = JsonDocument.create(id, content);
         JsonDocument inserted = bucket.insert(document);
@@ -70,12 +62,11 @@ public class CodeSnippets {
     }
 
     static JsonDocument getFirstFromReplicaExample(Bucket bucket, String id) {
-        try{
+        try {
             return bucket.get(id);
-        }
-        catch(CouchbaseException e) {
+        } catch (CouchbaseException e) {
             List<JsonDocument> list = bucket.getFromReplica(id, ReplicaMode.FIRST);
-            if(!list.isEmpty()) {
+            if (!list.isEmpty()) {
                 return list.get(0);
             }
         }
@@ -85,8 +76,8 @@ public class CodeSnippets {
     static JsonDocument getLatestReplicaVersion(Bucket bucket, String id) {
         long maxCasValue = -1;
         JsonDocument latest = null;
-        for(JsonDocument replica : bucket.getFromReplica(id, ReplicaMode.ALL)) {
-            if(replica.cas() > maxCasValue) {
+        for (JsonDocument replica : bucket.getFromReplica(id, ReplicaMode.ALL)) {
+            if (replica.cas() > maxCasValue) {
                 latest = replica;
                 maxCasValue = replica.cas();
             }

couchbase-sdk/src/main/java/com/baeldung/couchbase/spring/person/Person.java

@@ -7,7 +7,8 @@ public class Person {
     private String name;
     private String homeTown;
 
-    Person() {}
+    Person() {
+    }
 
     public Person(Builder b) {
         this.id = b.id;