Merge branch 'master' into pr/1084-stephen-brahimi-guava-eventbus

.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/pom.xml

@@ -0,0 +1,44 @@
+<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>algorithms</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+
+	<properties>
+		<junit.version>4.12</junit.version>
+		<maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
+		<exec-maven-plugin.version>1.5.0</exec-maven-plugin.version>
+	</properties>
+
+	<dependencies>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>${junit.version}</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>
+				<plugin>
+					<groupId>org.codehaus.mojo</groupId>
+					<artifactId>exec-maven-plugin</artifactId>
+					<version>${exec-maven-plugin.version}</version>
+				</plugin>
+			</plugins>
+		</pluginManagement>
+	</build>
+</project>

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

@@ -0,0 +1,57 @@
+package com.baeldung.algorithms.dijkstra;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map.Entry;
+import java.util.Set;
+
+public class Dijkstra {
+
+    public static Graph calculateShortestPathFromSource(Graph graph, Node source) {
+
+        source.setDistance(0);
+
+        Set<Node> settledNodes = new HashSet<>();
+        Set<Node> unsettledNodes = new HashSet<>();
+        unsettledNodes.add(source);
+
+        while (unsettledNodes.size() != 0) {
+            Node currentNode = getLowestDistanceNode(unsettledNodes);
+            unsettledNodes.remove(currentNode);
+            for (Entry<Node, Integer> adjacencyPair : currentNode.getAdjacentNodes().entrySet()) {
+                Node adjacentNode = adjacencyPair.getKey();
+                Integer edgeWeigh = adjacencyPair.getValue();
+
+                if (!settledNodes.contains(adjacentNode)) {
+                    CalculateMinimumDistance(adjacentNode, edgeWeigh, currentNode);
+                    unsettledNodes.add(adjacentNode);
+                }
+            }
+            settledNodes.add(currentNode);
+        }
+        return graph;
+    }
+
+    private static void CalculateMinimumDistance(Node evaluationNode, Integer edgeWeigh, Node sourceNode) {
+        Integer sourceDistance = sourceNode.getDistance();
+        if (sourceDistance + edgeWeigh < evaluationNode.getDistance()) {
+            evaluationNode.setDistance(sourceDistance + edgeWeigh);
+            LinkedList<Node> shortestPath = new LinkedList<>(sourceNode.getShortestPath());
+            shortestPath.add(sourceNode);
+            evaluationNode.setShortestPath(shortestPath);
+        }
+    }
+
+    private static Node getLowestDistanceNode(Set<Node> unsettledNodes) {
+        Node lowestDistanceNode = null;
+        int lowestDistance = Integer.MAX_VALUE;
+        for (Node node : unsettledNodes) {
+            int nodeDistance = node.getDistance();
+            if (nodeDistance < lowestDistance) {
+                lowestDistance = nodeDistance;
+                lowestDistanceNode = node;
+            }
+        }
+        return lowestDistanceNode;
+    }
+}

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

@@ -0,0 +1,21 @@
+package com.baeldung.algorithms.dijkstra;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Graph {
+
+    private Set<Node> nodes = new HashSet<>();
+
+    public void addNode(Node nodeA) {
+        nodes.add(nodeA);
+    }
+
+    public Set<Node> getNodes() {
+        return nodes;
+    }
+
+    public void setNodes(Set<Node> nodes) {
+        this.nodes = nodes;
+    }
+}

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

@@ -0,0 +1,58 @@
+package com.baeldung.algorithms.dijkstra;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+public class Node {
+
+    private String name;
+
+    private LinkedList<Node> shortestPath = new LinkedList<>();
+
+    private Integer distance = Integer.MAX_VALUE;
+
+    private Map<Node, Integer> adjacentNodes = new HashMap<>();
+
+    public Node(String name) {
+        this.name = name;
+    }
+
+    public void addDestination(Node destination, int distance) {
+        adjacentNodes.put(destination, distance);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Map<Node, Integer> getAdjacentNodes() {
+        return adjacentNodes;
+    }
+
+    public void setAdjacentNodes(Map<Node, Integer> adjacentNodes) {
+        this.adjacentNodes = adjacentNodes;
+    }
+
+    public Integer getDistance() {
+        return distance;
+    }
+
+    public void setDistance(Integer distance) {
+        this.distance = distance;
+    }
+
+    public List<Node> getShortestPath() {
+        return shortestPath;
+    }
+
+    public void setShortestPath(LinkedList<Node> shortestPath) {
+        this.shortestPath = shortestPath;
+    }
+
+}

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

@@ -0,0 +1,75 @@
+package algorithms;
+
+import com.baeldung.algorithms.dijkstra.Dijkstra;
+import com.baeldung.algorithms.dijkstra.Graph;
+import com.baeldung.algorithms.dijkstra.Node;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
+
+public class DijkstraAlgorithmTest {
+
+    @Test
+    public void whenSPPSolved_thenCorrect() {
+
+        Node nodeA = new Node("A");
+        Node nodeB = new Node("B");
+        Node nodeC = new Node("C");
+        Node nodeD = new Node("D");
+        Node nodeE = new Node("E");
+        Node nodeF = new Node("F");
+
+        nodeA.addDestination(nodeB, 10);
+        nodeA.addDestination(nodeC, 15);
+
+        nodeB.addDestination(nodeD, 12);
+        nodeB.addDestination(nodeF, 15);
+
+        nodeC.addDestination(nodeE, 10);
+
+        nodeD.addDestination(nodeE, 2);
+        nodeD.addDestination(nodeF, 1);
+
+        nodeF.addDestination(nodeE, 5);
+
+        Graph graph = new Graph();
+
+        graph.addNode(nodeA);
+        graph.addNode(nodeB);
+        graph.addNode(nodeC);
+        graph.addNode(nodeD);
+        graph.addNode(nodeE);
+        graph.addNode(nodeF);
+
+        graph = Dijkstra.calculateShortestPathFromSource(graph, nodeA);
+
+        List<Node> shortestPathForNodeB = Arrays.asList(nodeA);
+        List<Node> shortestPathForNodeC = Arrays.asList(nodeA);
+        List<Node> shortestPathForNodeD = Arrays.asList(nodeA, nodeB);
+        List<Node> shortestPathForNodeE = Arrays.asList(nodeA, nodeB, nodeD);
+        List<Node> shortestPathForNodeF = Arrays.asList(nodeA, nodeB, nodeD);
+
+        for (Node node : graph.getNodes()) {
+            switch (node.getName()) {
+            case "B":
+                assertTrue(node.getShortestPath().equals(shortestPathForNodeB));
+                break;
+            case "C":
+                assertTrue(node.getShortestPath().equals(shortestPathForNodeC));
+                break;
+            case "D":
+                assertTrue(node.getShortestPath().equals(shortestPathForNodeD));
+                break;
+            case "E":
+                assertTrue(node.getShortestPath().equals(shortestPathForNodeE));
+                break;
+            case "F":
+                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()
+            Map<Boolean, List<Element>> annotatedMethods = annotatedElements.stream().collect(Collectors.partitioningBy(element -> ((ExecutableType) element.asType()).getParameterTypes().size() == 1 && element.getSimpleName().toString().startsWith("set")));
-                    .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 ->
+            otherMethods.forEach(element -> processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "@BuilderProperty must be applied to a setXxx method with a single argument", 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(
+            Map<String, String> setterMap = setters.stream().collect(Collectors.toMap(setter -> setter.getSimpleName().toString(), setter -> ((ExecutableType) setter.asType()).getParameterTypes().get(0).toString()));
-                    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()
+        Person person = new PersonBuilder().setAge(25).setName("John").build();
-                .setAge(25)
-                .setName("John")
-                .build();
 
         assertEquals(25, person.getAge());
         assertEquals("John", person.getName());

annotations/pom.xml

@@ -1,7 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         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">
-         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>
         <groupId>com.baeldung</groupId>

apache-cxf/cxf-introduction/src/main/java/com/baeldung/cxf/introduction/Server.java

@@ -8,7 +8,7 @@ public class Server {
         String address = "http://localhost:8080/baeldung";
         Endpoint.publish(address, implementor);
         System.out.println("Server ready...");
-        Thread.sleep(60 * 1000);        
+        Thread.sleep(60 * 1000);
         System.out.println("Server exiting");
         System.exit(0);
     }

apache-cxf/cxf-jaxrs-implementation/src/main/java/com/baeldung/cxf/jaxrs/implementation/RestfulServer.java

@@ -11,7 +11,7 @@ public class RestfulServer {
         factoryBean.setResourceProvider(new SingletonResourceProvider(new CourseRepository()));
         factoryBean.setAddress("http://localhost:8080/");
         Server server = factoryBean.create();
-        
+
         System.out.println("Server ready...");
         Thread.sleep(60 * 1000);
         System.out.println("Server exiting");

apache-cxf/pom.xml

@@ -5,20 +5,20 @@
     <artifactId>apache-cxf</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <packaging>pom</packaging>
-    
+
     <modules>
         <module>cxf-introduction</module>
         <module>cxf-spring</module>
         <module>cxf-jaxrs-implementation</module>
         <module>cxf-aegis</module>
     </modules>
-    
+
     <properties>
         <junit.version>4.12</junit.version>
         <maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
         <exec-maven-plugin.version>1.5.0</exec-maven-plugin.version>
     </properties>
-    
+
     <dependencies>
         <dependency>
             <groupId>junit</groupId>
@@ -27,7 +27,7 @@
             <scope>test</scope>
         </dependency>
     </dependencies>
-    
+
     <build>
         <defaultGoal>install</defaultGoal>
         <pluginManagement>

apache-fop/pom.xml

@@ -1,154 +1,155 @@
-<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"
-	<modelVersion>4.0.0</modelVersion>
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-	<groupId>com.baeldung</groupId>
+    <modelVersion>4.0.0</modelVersion>
-	<artifactId>apache-fop</artifactId>
+    <groupId>com.baeldung</groupId>
-	<version>0.1-SNAPSHOT</version>
+    <artifactId>apache-fop</artifactId>
+    <version>0.1-SNAPSHOT</version>
 
-	<name>apache-fop</name>
+    <name>apache-fop</name>
 
-	<dependencies>
+    <dependencies>
 
-		<!-- logging -->
+        <!-- logging -->
 
-		<dependency>
+        <dependency>
-			<groupId>org.slf4j</groupId>
+            <groupId>org.slf4j</groupId>
-			<artifactId>slf4j-api</artifactId>
+            <artifactId>slf4j-api</artifactId>
-			<version>${org.slf4j.version}</version>
+            <version>${org.slf4j.version}</version>
-		</dependency>
+        </dependency>
-		<dependency>
+        <dependency>
-			<groupId>ch.qos.logback</groupId>
+            <groupId>ch.qos.logback</groupId>
-			<artifactId>logback-classic</artifactId>
+            <artifactId>logback-classic</artifactId>
-			<version>${logback.version}</version>
+            <version>${logback.version}</version>
-			<!-- <scope>runtime</scope> -->
+            <!-- <scope>runtime</scope> -->
-		</dependency>
+        </dependency>
-		<dependency>
+        <dependency>
-			<groupId>org.slf4j</groupId>
+            <groupId>org.slf4j</groupId>
-			<artifactId>jcl-over-slf4j</artifactId>
+            <artifactId>jcl-over-slf4j</artifactId>
-			<version>${org.slf4j.version}</version>
+            <version>${org.slf4j.version}</version>
-    <!-- <scope>runtime</scope> --> <!-- some spring dependencies need to compile against jcl -->
+            <!-- <scope>runtime</scope> --> <!-- some spring dependencies need to compile against jcl -->
-		</dependency>
+        </dependency>
-		<dependency> <!-- needed to bridge to slf4j for projects that use the log4j APIs directly -->
+        <dependency> <!-- needed to bridge to slf4j for projects that use the log4j APIs directly -->
-			<groupId>org.slf4j</groupId>
+            <groupId>org.slf4j</groupId>
-			<artifactId>log4j-over-slf4j</artifactId>
+            <artifactId>log4j-over-slf4j</artifactId>
-			<version>${org.slf4j.version}</version>
+            <version>${org.slf4j.version}</version>
-		</dependency>
+        </dependency>
 
-		<!-- test scoped -->
+        <!-- test scoped -->
 
-		<dependency>
+        <dependency>
-			<groupId>junit</groupId>
+            <groupId>junit</groupId>
-			<artifactId>junit</artifactId>
+            <artifactId>junit</artifactId>
-			<version>${junit.version}</version>
+            <version>${junit.version}</version>
-			<scope>test</scope>
+            <scope>test</scope>
-		</dependency>
+        </dependency>
 
-		<dependency>
+        <dependency>
-			<groupId>org.hamcrest</groupId>
+            <groupId>org.hamcrest</groupId>
-			<artifactId>hamcrest-core</artifactId>
+            <artifactId>hamcrest-core</artifactId>
-			<version>${org.hamcrest.version}</version>
+            <version>${org.hamcrest.version}</version>
-			<scope>test</scope>
+            <scope>test</scope>
-		</dependency>
+        </dependency>
-		<dependency>
+        <dependency>
-			<groupId>org.hamcrest</groupId>
+            <groupId>org.hamcrest</groupId>
-			<artifactId>hamcrest-library</artifactId>
+            <artifactId>hamcrest-library</artifactId>
-			<version>${org.hamcrest.version}</version>
+            <version>${org.hamcrest.version}</version>
-			<scope>test</scope>
+            <scope>test</scope>
-		</dependency>
+        </dependency>
 
-		<dependency>
+        <dependency>
-			<groupId>org.mockito</groupId>
+            <groupId>org.mockito</groupId>
-			<artifactId>mockito-core</artifactId>
+            <artifactId>mockito-core</artifactId>
-			<version>${mockito.version}</version>
+            <version>${mockito.version}</version>
-			<scope>test</scope>
+            <scope>test</scope>
-		</dependency>
+        </dependency>
 
-		<!-- new dependencies -->
+        <!-- new dependencies -->
 
-		<dependency>
+        <dependency>
-			<groupId>org.apache.xmlgraphics</groupId>
+            <groupId>org.apache.xmlgraphics</groupId>
-			<artifactId>fop</artifactId>
+            <artifactId>fop</artifactId>
-			<version>${fop.version}</version>
+            <version>${fop.version}</version>
-			<exclusions>
+            <exclusions>
-				<exclusion>
+                <exclusion>
-					<groupId>org.apache.avalon.framework</groupId>
+                    <groupId>org.apache.avalon.framework</groupId>
-					<artifactId>avalon-framework-api</artifactId>
+                    <artifactId>avalon-framework-api</artifactId>
-				</exclusion>
+                </exclusion>
-				<exclusion>
+                <exclusion>
-					<groupId>org.apache.avalon.framework</groupId>
+                    <groupId>org.apache.avalon.framework</groupId>
-					<artifactId>avalon-framework-impl</artifactId>
+                    <artifactId>avalon-framework-impl</artifactId>
-				</exclusion>
+                </exclusion>
-			</exclusions>
+            </exclusions>
-		</dependency>
+        </dependency>
 
-		<dependency>
+        <dependency>
-			<groupId>avalon-framework</groupId>
+            <groupId>avalon-framework</groupId>
-			<artifactId>avalon-framework-api</artifactId>
+            <artifactId>avalon-framework-api</artifactId>
-			<version>${avalon-framework.version}</version>
+            <version>${avalon-framework.version}</version>
-		</dependency>
+        </dependency>
-		<dependency>
+        <dependency>
-			<groupId>avalon-framework</groupId>
+            <groupId>avalon-framework</groupId>
-			<artifactId>avalon-framework-impl</artifactId>
+            <artifactId>avalon-framework-impl</artifactId>
-			<version>${avalon-framework.version}</version>
+            <version>${avalon-framework.version}</version>
-		</dependency>
+        </dependency>
 
-		<dependency>
+        <dependency>
-			<groupId>org.dbdoclet</groupId>
+            <groupId>org.dbdoclet</groupId>
-			<artifactId>dbdoclet</artifactId>
+            <artifactId>dbdoclet</artifactId>
-			<version>${dbdoclet.version}</version>
+            <version>${dbdoclet.version}</version>
-		</dependency>
+        </dependency>
 
-		<dependency>
+        <dependency>
-		  <groupId>org.dbdoclet</groupId>
+            <groupId>org.dbdoclet</groupId>
-		  <artifactId>herold</artifactId>
+            <artifactId>herold</artifactId>
-		  <version>6.1.0</version>
+            <version>6.1.0</version>
-		  <scope>system</scope>
+            <scope>system</scope>
-		  <systemPath>${basedir}/src/test/resources/jars/herold.jar</systemPath>
+            <systemPath>${basedir}/src/test/resources/jars/herold.jar</systemPath>
-		</dependency>
+        </dependency>
-		
-		<dependency>
-			<groupId>net.sf.jtidy</groupId>
-			<artifactId>jtidy</artifactId>
-			<version>${jtidy.version}</version>
-		</dependency>
 
-	</dependencies>
+        <dependency>
+            <groupId>net.sf.jtidy</groupId>
+            <artifactId>jtidy</artifactId>
+            <version>${jtidy.version}</version>
+        </dependency>
 
-	<build>
+    </dependencies>
-		<finalName>apache-fop</finalName>
-		<resources>
-			<resource>
-				<directory>src/main/resources</directory>
-				<filtering>true</filtering>
-			</resource>
-		</resources>
 
-		<plugins>
+    <build>
+        <finalName>apache-fop</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
 
-			<plugin>
+        <plugins>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-compiler-plugin</artifactId>
-				<version>${maven-compiler-plugin.version}</version>
-				<configuration>
-					<source>1.7</source>
-					<target>1.7</target>
-				</configuration>
-			</plugin>
 
-			<plugin>
+            <plugin>
-				<groupId>org.apache.maven.plugins</groupId>
+                <groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
+                <artifactId>maven-compiler-plugin</artifactId>
-				<version>${maven-surefire-plugin.version}</version>
+                <version>${maven-compiler-plugin.version}</version>
-				<configuration>
+                <configuration>
-					<excludes>
+                    <source>1.7</source>
+                    <target>1.7</target>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${maven-surefire-plugin.version}</version>
+                <configuration>
+                    <excludes>
                         <exclude>**/*IntegrationTest.java</exclude>
                         <exclude>**/*LiveTest.java</exclude>
-					</excludes>
+                    </excludes>
-				</configuration>
+                </configuration>
-			</plugin>
+            </plugin>
 
-		</plugins>
+        </plugins>
 
-	</build>
+    </build>
 
     <profiles>
         <profile>
@@ -170,7 +171,7 @@
                                     </excludes>
                                     <includes>
                                         <include>**/*IntegrationTest.java</include>
-                                        <exclude>**/*LiveTest.java</exclude>                                        
+                                        <exclude>**/*LiveTest.java</exclude>
                                     </includes>
                                 </configuration>
                             </execution>
@@ -185,25 +186,25 @@
             </build>
         </profile>
     </profiles>
-    
-	<properties>
-	    <fop.version>1.1</fop.version> 
-	    <avalon-framework.version>4.3</avalon-framework.version>
-	    <dbdoclet.version>8.0.2</dbdoclet.version>
-	    <jtidy.version>r938</jtidy.version>
-		<!-- logging -->
-		<org.slf4j.version>1.7.21</org.slf4j.version>
-		<logback.version>1.1.7</logback.version>
 
-		<!-- testing -->
+    <properties>
-		<org.hamcrest.version>1.3</org.hamcrest.version>
+        <fop.version>1.1</fop.version>
-		<junit.version>4.12</junit.version>
+        <avalon-framework.version>4.3</avalon-framework.version>
-		<mockito.version>1.10.19</mockito.version>
+        <dbdoclet.version>8.0.2</dbdoclet.version>
+        <jtidy.version>r938</jtidy.version>
+        <!-- logging -->
+        <org.slf4j.version>1.7.21</org.slf4j.version>
+        <logback.version>1.1.7</logback.version>
 
-		<!-- maven plugins -->
+        <!-- testing -->
-		<maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
+        <org.hamcrest.version>1.3</org.hamcrest.version>
-		<maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>
+        <junit.version>4.12</junit.version>
+        <mockito.version>1.10.19</mockito.version>
 
-	</properties>
+        <!-- maven plugins -->
+        <maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
+        <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>
+
+    </properties>
 
 </project>

apache-poi/README.md

@@ -0,0 +1,2 @@
+### Relevant Articles:
+- [Microsoft Word Processing in Java with Apache POI](http://www.baeldung.com/java-microsoft-word-with-apache-poi)

aspectj/README.md

@@ -0,0 +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

@@ -12,39 +12,69 @@
             <artifactId>aspectjrt</artifactId>
             <version>${aspectj.version}</version>
         </dependency>
-        
+
         <dependency>
             <groupId>org.aspectj</groupId>
             <artifactId>aspectjweaver</artifactId>
             <version>${aspectj.version}</version>
         </dependency>
-    
+
         <!-- utils -->
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
             <version>${org.slf4j.version}</version>
         </dependency>
-        
+
         <dependency>
             <groupId>ch.qos.logback</groupId>
             <artifactId>logback-classic</artifactId>
             <version>${logback.version}</version>
         </dependency>
-        
+
         <dependency>
             <groupId>ch.qos.logback</groupId>
             <artifactId>logback-core</artifactId>
             <version>${logback.version}</version>
         </dependency>
-        
+
         <!-- unit test -->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>${junit.version}</version>
         </dependency>
-        
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <version>4.3.4.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-beans</artifactId>
+            <version>4.3.4.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-core</artifactId>
+            <version>4.3.4.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>cglib</groupId>
+            <artifactId>cglib</artifactId>
+            <version>3.2.4</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-aop</artifactId>
+            <version>4.3.4.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>1.2.17</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -65,9 +95,9 @@
                     <source>${source.version}</source>
                     <target>${source.version}</target>
                 </configuration>
-              
+
             </plugin>
-            
+
             <plugin>
                 <groupId>org.codehaus.mojo</groupId>
                 <artifactId>aspectj-maven-plugin</artifactId>
@@ -81,41 +111,22 @@
                     <Xlint>ignore</Xlint>
                     <encoding>${project.build.sourceEncoding}</encoding>
                     <!-- Post-compile weaving -->
-                    <!--
+                    <!-- <weaveDependencies> <weaveDependency> <groupId>org.agroup</groupId> <artifactId>to-weave</artifactId> </weaveDependency> 
-                    <weaveDependencies>
+                        <weaveDependency> <groupId>org.anothergroup</groupId> <artifactId>gen</artifactId> </weaveDependency> </weaveDependencies> -->
-                        <weaveDependency>
+                </configuration>
-                              <groupId>org.agroup</groupId>
-                              <artifactId>to-weave</artifactId>
-                        </weaveDependency>
-                        <weaveDependency>
-                              <groupId>org.anothergroup</groupId>
-                              <artifactId>gen</artifactId>
-                        </weaveDependency>
-                      </weaveDependencies>
-                      -->
-                </configuration> 
                 <executions>
                     <execution>
                         <goals>
                             <goal>compile</goal>
-                            <goal>test-compile</goal> 
+                            <goal>test-compile</goal>
                         </goals>
                     </execution>
                 </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>
 

aspectj/src/main/java/com/baeldung/performancemonitor/AopConfiguration.java

@@ -0,0 +1,59 @@
+package com.baeldung.performancemonitor;
+
+import java.time.LocalDate;
+import java.time.Month;
+
+import org.aspectj.lang.annotation.Pointcut;
+import org.springframework.aop.Advisor;
+import org.springframework.aop.aspectj.AspectJExpressionPointcut;
+import org.springframework.aop.interceptor.PerformanceMonitorInterceptor;
+import org.springframework.aop.support.DefaultPointcutAdvisor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.EnableAspectJAutoProxy;
+
+@Configuration
+@EnableAspectJAutoProxy
+public class AopConfiguration {
+    
+    @Pointcut("execution(public String com.baeldung.performancemonitor.PersonService.getFullName(..))")
+    public void monitor() { }
+    
+    @Pointcut("execution(public int com.baeldung.performancemonitor.PersonService.getAge(..))")
+    public void myMonitor() { }
+    
+    @Bean
+    public PerformanceMonitorInterceptor performanceMonitorInterceptor() {
+        return new PerformanceMonitorInterceptor(true);
+    }
+
+    @Bean
+    public Advisor performanceMonitorAdvisor() {
+        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
+        pointcut.setExpression("com.baeldung.performancemonitor.AopConfiguration.monitor()");
+        return new DefaultPointcutAdvisor(pointcut, performanceMonitorInterceptor());
+    }
+    
+    @Bean
+    public Person person(){
+        return new Person("John","Smith", LocalDate.of(1980, Month.JANUARY, 12));
+    }
+    
+    @Bean
+    public PersonService personService(){
+        return new PersonService();
+    }
+    
+    @Bean
+    public MyPerformanceMonitorInterceptor myPerformanceMonitorInterceptor() {
+        return new MyPerformanceMonitorInterceptor(true);
+    }
+    
+    @Bean
+    public Advisor myPerformanceMonitorAdvisor() {
+        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
+        pointcut.setExpression("com.baeldung.performancemonitor.AopConfiguration.myMonitor()");
+        return new DefaultPointcutAdvisor(pointcut, myPerformanceMonitorInterceptor());
+    }
+    
+}

aspectj/src/main/java/com/baeldung/performancemonitor/MyPerformanceMonitorInterceptor.java

@@ -0,0 +1,39 @@
+package com.baeldung.performancemonitor;
+
+import java.util.Date;
+
+import org.aopalliance.intercept.MethodInvocation;
+import org.apache.commons.logging.Log;
+import org.springframework.aop.interceptor.AbstractMonitoringInterceptor;
+
+public class MyPerformanceMonitorInterceptor extends AbstractMonitoringInterceptor {
+    
+    public MyPerformanceMonitorInterceptor() {
+    }
+
+    public MyPerformanceMonitorInterceptor(boolean useDynamicLogger) {
+            setUseDynamicLogger(useDynamicLogger);
+    }
+
+    @Override
+    protected Object invokeUnderTrace(MethodInvocation invocation, Log log) throws Throwable {
+        
+        String name = createInvocationTraceName(invocation);
+        long start = System.currentTimeMillis();
+        log.info("Method "+name+" execution started at:"+new Date());
+        try {
+            return invocation.proceed();
+        }
+        finally {
+            long end = System.currentTimeMillis();
+            long time = end - start;
+            log.info("Method "+name+" execution lasted:"+time+" ms");
+            log.info("Method "+name+" execution ended at:"+new Date());
+            
+            if (time > 10){
+                log.warn("Method execution longer than 10 ms!");
+            }
+            
+        }
+    }
+}

aspectj/src/main/java/com/baeldung/performancemonitor/PerfomanceApp.java

@@ -0,0 +1,16 @@
+package com.baeldung.performancemonitor;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+
+public class PerfomanceApp {
+    public static void main(String[] args) {
+
+        ApplicationContext context = new AnnotationConfigApplicationContext(AopConfiguration.class);
+        Person person = (Person) context.getBean("person");
+        PersonService personService = (PersonService) context.getBean("personService");
+        
+        System.out.println("Name is:"+personService.getFullName(person));
+        System.out.println("Age is:"+personService.getAge(person));
+    }
+}

aspectj/src/main/java/com/baeldung/performancemonitor/Person.java

@@ -0,0 +1,42 @@
+package com.baeldung.performancemonitor;
+
+import java.time.LocalDate;
+
+public class Person {
+    private String lastName;
+    private String firstName;
+    private LocalDate dateOfBirth;
+
+    public Person() {
+    }
+
+    public Person(String firstName, String lastName, LocalDate dateOfBirth) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.dateOfBirth = dateOfBirth;
+    }
+
+    public LocalDate getDateOfBirth() {
+        return dateOfBirth;
+    }
+
+    public void setDateOfBirth(LocalDate dateOfBirth) {
+        this.dateOfBirth = dateOfBirth;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+}

aspectj/src/main/java/com/baeldung/performancemonitor/PersonService.java

@@ -0,0 +1,17 @@
+package com.baeldung.performancemonitor;
+
+import java.time.LocalDate;
+import java.time.Period;
+
+public class PersonService {
+
+    public String getFullName(Person person){
+        return person.getLastName()+" "+person.getFirstName();
+    }
+    
+    public int getAge(Person person){
+        Period p = Period.between(person.getDateOfBirth(), LocalDate.now());
+        return p.getYears();
+    }
+    
+}

aspectj/src/main/resources/log4j.properties

@@ -0,0 +1,10 @@
+log4j.rootLogger=TRACE, stdout
+
+# Redirect log messages to console
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.Target=System.out
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
+
+log4j.logger.org.springframework.aop.interceptor.PerformanceMonitorInterceptor=TRACE, stdout
+log4j.logger.com.baeldung.performancemonitor.MyPerformanceMonitorInterceptor=INFO, stdout

assertj/pom.xml

@@ -54,8 +54,8 @@
         <assertj-guava.version>3.1.0</assertj-guava.version>
         <junit.version>4.12</junit.version>
         <assertj-core.version>3.6.1</assertj-core.version>
-        
+
         <maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
     </properties>
-    
+
 </project>

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)
+        assertThat(list).contains("1");
-                .contains("1");
     }
 
     @Test
@@ -50,12 +49,7 @@ public class AssertJCoreTest {
         assertThat(list).startsWith("1");
         assertThat(list).doesNotContainNull();
 
-        assertThat(list)
+        assertThat(list).isNotEmpty().contains("1").startsWith("1").doesNotContainNull().containsSequence("2", "3");
-                .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)
+        assertThat(someCharacter).isNotEqualTo('a').inUnicode().isGreaterThanOrEqualTo('b').isLowerCase();
-                .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)
+        assertThat(someFile).exists().isFile().canRead().canWrite();
-                .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)
+        assertThat(map).isNotEmpty().containsKey(2).doesNotContainKeys(10).contains(entry(2, "a"));
-                .isNotEmpty()
-                .containsKey(2)
-                .doesNotContainKeys(10)
-                .contains(entry(2, "a"));
     }
 
     @Test
     public void whenGivenException_then() throws Exception {
         Exception ex = new Exception("abc");
 
-        assertThat(ex)
+        assertThat(ex).hasNoCause().hasMessageEndingWith("c");
-                .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())
+        assertThat(person.getAge()).as("%s's age should be equal to 100").isEqualTo(100);
-                .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))
+        assertThat(Files.asByteSource(temp1)).hasSize(0).hasSameContentAs(Files.asByteSource(temp2));
-                .hasSize(0)
-                .hasSameContentAs(Files.asByteSource(temp2));
     }
 
     @Test
@@ -37,11 +35,7 @@ public class AssertJGuavaTest {
         mmap.put(1, "one");
         mmap.put(1, "1");
 
-        assertThat(mmap)
+        assertThat(mmap).hasSize(2).containsKeys(1).contains(entry(1, "one")).contains(entry(1, "1"));
-                .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)
+        assertThat(mmap1).containsAllEntriesOf(mmap2).containsAllEntriesOf(mmap1_clone).hasSameEntriesAs(mmap1_clone);
-                .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)
+        assertThat(something).isPresent().extractingValue().isEqualTo("something");
-                .isPresent()
-                .extractingValue()
-                .isEqualTo("something");
     }
 
     @Test
     public void givenRange_whenVerifying_thenShouldBeCorrect() throws Exception {
         final Range<String> range = Range.openClosed("a", "g");
 
-        assertThat(range)
+        assertThat(range).hasOpenedLowerBound().isNotEmpty().hasClosedUpperBound().contains("b");
-                .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)
+        assertThat(map).isNotEmpty().containsKeys(0).contains(MapEntry.entry(34, "F"));
-                .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)
+        assertThat(table).hasRowCount(1).containsValues("ABSENT").containsCell(1, "B", "ABSENT");
-                .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)
+        assertThat(givenOptional).isPresent().hasValue("something");
-          .isPresent()
-          .hasValue("something");
     }
 
     @Test
     public void givenPredicate_shouldAssert() throws Exception {
         final Predicate<String> predicate = s -> s.length() > 4;
 
-        assertThat(predicate)
+        assertThat(predicate).accepts("aaaaa", "bbbbb").rejects("a", "b").acceptsAll(asList("aaaaa", "bbbbb")).rejectsAll(asList("a", "b"));
-          .accepts("aaaaa", "bbbbb")
-          .rejects("a", "b")
-          .acceptsAll(asList("aaaaa", "bbbbb"))
-          .rejectsAll(asList("a", "b"));
     }
 
     @Test
@@ -41,92 +35,74 @@ public class AssertJJava8Test {
         final LocalDate givenLocalDate = LocalDate.of(2016, 7, 8);
         final LocalDate todayDate = LocalDate.now();
 
-        assertThat(givenLocalDate)
+        assertThat(givenLocalDate).isBefore(LocalDate.of(2020, 7, 8)).isAfterOrEqualTo(LocalDate.of(1989, 7, 8));
-          .isBefore(LocalDate.of(2020, 7, 8))
-          .isAfterOrEqualTo(LocalDate.of(1989, 7, 8));
 
-        assertThat(todayDate)
+        assertThat(todayDate).isAfter(LocalDate.of(1989, 7, 8)).isToday();
-          .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)
+        assertThat(givenLocalDate).isBefore(LocalDateTime.of(2020, 7, 8, 11, 2));
-          .isBefore(LocalDateTime.of(2020, 7, 8, 11, 2));
     }
 
     @Test
     public void givenLocalTime_shouldAssert() throws Exception {
         final LocalTime givenLocalTime = LocalTime.of(12, 15);
 
-        assertThat(givenLocalTime)
+        assertThat(givenLocalTime).isAfter(LocalTime.of(1, 0)).hasSameHourAs(LocalTime.of(12, 0));
-          .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)
+        assertThat(givenList).flatExtracting(LocalDate::getYear).contains(2015);
-          .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)
+        assertThat(givenList).flatExtracting(LocalDate::isLeapYear).contains(true);
-          .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)
+        assertThat(givenList).flatExtracting(Object::getClass).contains(LocalDate.class);
-          .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)
+        assertThat(givenList).flatExtracting(LocalDate::getYear, LocalDate::getDayOfMonth).contains(2015, 6);
-          .flatExtracting(LocalDate::getYear, LocalDate::getDayOfMonth)
-          .contains(2015, 6);
     }
 
     @Test
     public void givenString_shouldSatisfy() throws Exception {
         final String givenString = "someString";
 
-        assertThat(givenString)
+        assertThat(givenString).satisfies(s -> {
-          .satisfies(s -> {
+            assertThat(s).isNotEmpty();
-              assertThat(s).isNotEmpty();
+            assertThat(s).hasSize(10);
-              assertThat(s).hasSize(10);
+        });
-          });
     }
 
     @Test
     public void givenString_shouldMatch() throws Exception {
         final String emptyString = "";
 
-        assertThat(emptyString)
+        assertThat(emptyString).matches(String::isEmpty);
-          .matches(String::isEmpty);
     }
 
     @Test
     public void givenList_shouldHasOnlyOneElementSatisfying() throws Exception {
         final List<String> givenList = Arrays.asList("");
 
-        assertThat(givenList)
+        assertThat(givenList).hasOnlyOneElementSatisfying(s -> assertThat(s).isEmpty());
-          .hasOnlyOneElementSatisfying(s -> assertThat(s).isEmpty());
     }
 }

autovalue/pom.xml

@@ -41,5 +41,5 @@
         <junit.version>4.12</junit.version>
         <maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
     </properties>
-    
+
 </project>

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

@@ -4,12 +4,12 @@ import com.google.auto.value.AutoValue;
 
 @AutoValue
 public abstract class AutoValueMoney {
-	public abstract String getCurrency();
+    public abstract String getCurrency();
 
-	public abstract long getAmount();
+    public abstract long getAmount();
 
-	public static AutoValueMoney create(String currency, long amount) {
+    public static AutoValueMoney create(String currency, long amount) {
-		return new AutoValue_AutoValueMoney(currency, amount);
+        return new AutoValue_AutoValueMoney(currency, amount);
 
-	}
+    }
 }

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

@@ -4,20 +4,20 @@ import com.google.auto.value.AutoValue;
 
 @AutoValue
 public abstract class AutoValueMoneyWithBuilder {
-	public abstract String getCurrency();
+    public abstract String getCurrency();
 
-	public abstract long getAmount();
+    public abstract long getAmount();
 
-	static Builder builder() {
+    static Builder builder() {
-		return new AutoValue_AutoValueMoneyWithBuilder.Builder();
+        return new AutoValue_AutoValueMoneyWithBuilder.Builder();
-	}
+    }
 
-	@AutoValue.Builder
+    @AutoValue.Builder
-	abstract static class Builder {
+    abstract static class Builder {
-		abstract Builder setCurrency(String currency);
+        abstract Builder setCurrency(String currency);
 
-		abstract Builder setAmount(long amount);
+        abstract Builder setAmount(long amount);
 
-		abstract AutoValueMoneyWithBuilder build();
+        abstract AutoValueMoneyWithBuilder build();
-	}
+    }
 }

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

@@ -3,49 +3,49 @@ package com.baeldung.autovalue;
 import java.util.Objects;
 
 public final class Foo {
-	private final String text;
+    private final String text;
-	private final int number;
+    private final int number;
 
-	public Foo(String text, int number) {
+    public Foo(String text, int number) {
-		this.text = text;
+        this.text = text;
-		this.number = number;
+        this.number = number;
-	}
+    }
 
-	public String getText() {
+    public String getText() {
-		return text;
+        return text;
-	}
+    }
 
-	public int getNumber() {
+    public int getNumber() {
-		return number;
+        return number;
-	}
+    }
 
-	@Override
+    @Override
-	public int hashCode() {
+    public int hashCode() {
-		return Objects.hash(text, number);
+        return Objects.hash(text, number);
-	}
+    }
 
-	@Override
+    @Override
-	public String toString() {
+    public String toString() {
-		return "Foo [text=" + text + ", number=" + number + "]";
+        return "Foo [text=" + text + ", number=" + number + "]";
-	}
+    }
 
-	@Override
+    @Override
-	public boolean equals(Object obj) {
+    public boolean equals(Object obj) {
-		if (this == obj)
+        if (this == obj)
-			return true;
+            return true;
-		if (obj == null)
+        if (obj == null)
-			return false;
+            return false;
-		if (getClass() != obj.getClass())
+        if (getClass() != obj.getClass())
-			return false;
+            return false;
-		Foo other = (Foo) obj;
+        Foo other = (Foo) obj;
-		if (number != other.number)
+        if (number != other.number)
-			return false;
+            return false;
-		if (text == null) {
+        if (text == null) {
-			if (other.text != null)
+            if (other.text != null)
-				return false;
+                return false;
-		} else if (!text.equals(other.text))
+        } else if (!text.equals(other.text))
-			return false;
+            return false;
-		return true;
+        return true;
-	}
+    }
 
 }

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

@@ -1,52 +1,53 @@
 package com.baeldung.autovalue;
+
 public final class ImmutableMoney {
-	private final long amount;
+    private final long amount;
-	private final String currency;
+    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());
-		return result;
-	}
 
-	@Override
+    public ImmutableMoney(long amount, String currency) {
-	public boolean equals(Object obj) {
+        this.amount = amount;
-		if (this == obj)
+        this.currency = currency;
-			return true;
+    }
-		if (obj == null)
-			return false;
-		if (getClass() != obj.getClass())
-			return false;
-		ImmutableMoney other = (ImmutableMoney) obj;
-		if (amount != other.amount)
-			return false;
-		if (currency == null) {
-			if (other.currency != null)
-				return false;
-		} else if (!currency.equals(other.currency))
-			return false;
-		return true;
-	}
 
-	public long getAmount() {
+    @Override
-		return amount;
+    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());
+        return result;
+    }
 
-	public String getCurrency() {
+    @Override
-		return currency;
+    public boolean equals(Object obj) {
-	}
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        ImmutableMoney other = (ImmutableMoney) obj;
+        if (amount != other.amount)
+            return false;
+        if (currency == null) {
+            if (other.currency != null)
+                return false;
+        } else if (!currency.equals(other.currency))
+            return false;
+        return true;
+    }
 
-	@Override
+    public long getAmount() {
-	public String toString() {
+        return amount;
-		return "ImmutableMoney [amount=" + amount + ", currency=" + currency
+    }
-				+ "]";
+
-	}
+    public String getCurrency() {
+        return currency;
+    }
+
+    @Override
+    public String toString() {
+        return "ImmutableMoney [amount=" + amount + ", currency=" + currency + "]";
+    }
 
 }

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

@@ -1,35 +1,34 @@
 package com.baeldung.autovalue;
 
 public class MutableMoney {
-	@Override
+    @Override
-	public String toString() {
+    public String toString() {
-		return "MutableMoney [amount=" + amount + ", currency=" + currency
+        return "MutableMoney [amount=" + amount + ", currency=" + currency + "]";
-				+ "]";
+    }
-	}
 
-	public long getAmount() {
+    public long getAmount() {
-		return amount;
+        return amount;
-	}
+    }
 
-	public void setAmount(long amount) {
+    public void setAmount(long amount) {
-		this.amount = amount;
+        this.amount = amount;
-	}
+    }
 
-	public String getCurrency() {
+    public String getCurrency() {
-		return currency;
+        return currency;
-	}
+    }
 
-	public void setCurrency(String currency) {
+    public void setCurrency(String currency) {
-		this.currency = currency;
+        this.currency = currency;
-	}
+    }
 
-	private long amount;
+    private long amount;
-	private String currency;
+    private String currency;
 
-	public MutableMoney(long amount, String currency) {
+    public MutableMoney(long amount, String currency) {
-		super();
+        super();
-		this.amount = amount;
+        this.amount = amount;
-		this.currency = currency;
+        this.currency = currency;
-	}
+    }
 
 }

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

@@ -5,55 +5,59 @@ import static org.junit.Assert.*;
 import org.junit.Test;
 
 public class MoneyUnitTest {
-	@Test
+    @Test
-	public void givenTwoSameValueMoneyObjects_whenEqualityTestFails_thenCorrect() {
+    public void givenTwoSameValueMoneyObjects_whenEqualityTestFails_thenCorrect() {
-		MutableMoney m1 = new MutableMoney(10000, "USD");
+        MutableMoney m1 = new MutableMoney(10000, "USD");
-		MutableMoney m2 = new MutableMoney(10000, "USD");
+        MutableMoney m2 = new MutableMoney(10000, "USD");
-		assertFalse(m1.equals(m2));
+        assertFalse(m1.equals(m2));
-	}
+    }
 
-	@Test
+    @Test
-	public void givenTwoSameValueMoneyValueObjects_whenEqualityTestPasses_thenCorrect() {
+    public void givenTwoSameValueMoneyValueObjects_whenEqualityTestPasses_thenCorrect() {
-		ImmutableMoney m1 = new ImmutableMoney(10000, "USD");
+        ImmutableMoney m1 = new ImmutableMoney(10000, "USD");
-		ImmutableMoney m2 = new ImmutableMoney(10000, "USD");
+        ImmutableMoney m2 = new ImmutableMoney(10000, "USD");
-		assertTrue(m1.equals(m2));
+        assertTrue(m1.equals(m2));
-	}
+    }
 
-	@Test
+    @Test
-	public void givenValueTypeWithAutoValue_whenFieldsCorrectlySet_thenCorrect() {
+    public void givenValueTypeWithAutoValue_whenFieldsCorrectlySet_thenCorrect() {
-		AutoValueMoney m = AutoValueMoney.create("USD", 10000);
+        AutoValueMoney m = AutoValueMoney.create("USD", 10000);
-		assertEquals(m.getAmount(), 10000);
+        assertEquals(m.getAmount(), 10000);
-		assertEquals(m.getCurrency(), "USD");
+        assertEquals(m.getCurrency(), "USD");
-	}
+    }
 
-	@Test
+    @Test
-	public void given2EqualValueTypesWithAutoValue_whenEqual_thenCorrect() {
+    public void given2EqualValueTypesWithAutoValue_whenEqual_thenCorrect() {
-		AutoValueMoney m1 = AutoValueMoney.create("USD", 5000);
+        AutoValueMoney m1 = AutoValueMoney.create("USD", 5000);
-		AutoValueMoney m2 = AutoValueMoney.create("USD", 5000);
+        AutoValueMoney m2 = AutoValueMoney.create("USD", 5000);
-		assertTrue(m1.equals(m2));
+        assertTrue(m1.equals(m2));
-	}
+    }
-	@Test
+
-	public void given2DifferentValueTypesWithAutoValue_whenNotEqual_thenCorrect() {
+    @Test
-		AutoValueMoney m1 = AutoValueMoney.create("GBP", 5000);
+    public void given2DifferentValueTypesWithAutoValue_whenNotEqual_thenCorrect() {
-		AutoValueMoney m2 = AutoValueMoney.create("USD", 5000);
+        AutoValueMoney m1 = AutoValueMoney.create("GBP", 5000);
-		assertFalse(m1.equals(m2));
+        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();
+    @Test
-		AutoValueMoneyWithBuilder m2 = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("USD").build();
+    public void given2EqualValueTypesWithBuilder_whenEqual_thenCorrect() {
-		assertTrue(m1.equals(m2));
+        AutoValueMoneyWithBuilder m1 = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("USD").build();
-	}
+        AutoValueMoneyWithBuilder m2 = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("USD").build();
-	@Test
+        assertTrue(m1.equals(m2));
-	public void given2DifferentValueTypesBuilder_whenNotEqual_thenCorrect() {
+    }
-		AutoValueMoneyWithBuilder m1 = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("USD").build();
+
-		AutoValueMoneyWithBuilder m2 = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("GBP").build();
+    @Test
-		assertFalse(m1.equals(m2));
+    public void given2DifferentValueTypesBuilder_whenNotEqual_thenCorrect() {
-	}
+        AutoValueMoneyWithBuilder m1 = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("USD").build();
-	@Test
+        AutoValueMoneyWithBuilder m2 = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("GBP").build();
-	public void givenValueTypeWithBuilder_whenFieldsCorrectlySet_thenCorrect() {
+        assertFalse(m1.equals(m2));
-		AutoValueMoneyWithBuilder m = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("USD").build();
+    }
-		assertEquals(m.getAmount(), 5000);
+
-		assertEquals(m.getCurrency(), "USD");
+    @Test
-	}
+    public void givenValueTypeWithBuilder_whenFieldsCorrectlySet_thenCorrect() {
+        AutoValueMoneyWithBuilder m = AutoValueMoneyWithBuilder.builder().setAmount(5000).setCurrency("USD").build();
+        assertEquals(m.getAmount(), 5000);
+        assertEquals(m.getCurrency(), "USD");
+    }
 }

aws/.gitignore

@@ -0,0 +1 @@
+/target/

aws/pom.xml

@@ -2,10 +2,10 @@
 		 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>aws-lambda</artifactId>
+	<artifactId>aws</artifactId>
 	<version>0.1.0-SNAPSHOT</version>
 	<packaging>jar</packaging>
-	<name>aws-lambda</name>
+	<name>aws</name>
 
 	<dependencies>
 		<dependency>

aws/src/main/java/com/baeldung/lambda/LambdaMethodHandler.java

@@ -1,4 +1,4 @@
-package com.baeldung;
+package com.baeldung.lambda;
 
 import com.amazonaws.services.lambda.runtime.Context;
 

aws/src/main/java/com/baeldung/lambda/LambdaRequestHandler.java

@@ -1,4 +1,4 @@
-package com.baeldung;
+package com.baeldung.lambda;
 
 import com.amazonaws.services.lambda.runtime.Context;
 import com.amazonaws.services.lambda.runtime.RequestHandler;

aws/src/main/java/com/baeldung/lambda/LambdaRequestStreamHandler.java

@@ -1,7 +1,6 @@
-package com.baeldung;
+package com.baeldung.lambda;
 
 import com.amazonaws.services.lambda.runtime.Context;
-import com.amazonaws.services.lambda.runtime.RequestHandler;
 import com.amazonaws.services.lambda.runtime.RequestStreamHandler;
 import org.apache.commons.io.IOUtils;
 

cdi/pom.xml

@@ -45,7 +45,7 @@
 
     </dependencies>
 
-    
+
     <build>
         <plugins>
             <plugin>
@@ -61,7 +61,7 @@
             </plugin>
         </plugins>
     </build>
-    
+
     <profiles>
         <profile>
             <id>integration</id>
@@ -101,7 +101,7 @@
         <aspectjweaver.version>1.8.9</aspectjweaver.version>
         <weld-se-core.version>2.4.1.Final</weld-se-core.version>
         <junit.version>4.12</junit.version>
-        <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>        
+        <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>
     </properties>
 
 </project>

core-java-9/pom.xml

@@ -1,91 +1,90 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" 
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-		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">
-		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>
-	<modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
-	<groupId>com.baeldung</groupId>
+    <artifactId>core-java9</artifactId>
-	<artifactId>core-java9</artifactId>
+    <version>0.2-SNAPSHOT</version>
-	<version>0.2-SNAPSHOT</version>
 
-	<name>core-java9</name>
+    <name>core-java9</name>
 
-	<pluginRepositories>
+    <pluginRepositories>
-		<pluginRepository>
+        <pluginRepository>
-			<id>apache.snapshots</id>
+            <id>apache.snapshots</id>
-			<url>http://repository.apache.org/snapshots/</url>
+            <url>http://repository.apache.org/snapshots/</url>
-		</pluginRepository>
+        </pluginRepository>
-	</pluginRepositories>
+    </pluginRepositories>
 
-	<dependencies>
+    <dependencies>
 
-		<dependency>
+        <dependency>
-			<groupId>org.slf4j</groupId>
+            <groupId>org.slf4j</groupId>
-			<artifactId>slf4j-api</artifactId>
+            <artifactId>slf4j-api</artifactId>
-			<version>${org.slf4j.version}</version>
+            <version>${org.slf4j.version}</version>
-		</dependency>
+        </dependency>
 
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-library</artifactId>
+            <version>${org.hamcrest.version}</version>
+            <scope>test</scope>
+        </dependency>
 
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
 
-		<dependency>
+        <dependency>
-			<groupId>org.hamcrest</groupId>
+            <groupId>org.mockito</groupId>
-			<artifactId>hamcrest-library</artifactId>
+            <artifactId>mockito-core</artifactId>
-			<version>${org.hamcrest.version}</version>
+            <version>${mockito.version}</version>
-			<scope>test</scope>
+            <scope>test</scope>
-		</dependency>
+        </dependency>
 
-		<dependency>
+    </dependencies>
-			<groupId>junit</groupId>
-			<artifactId>junit</artifactId>
-			<version>${junit.version}</version>
-			<scope>test</scope>
-		</dependency>
 
-		<dependency>
+    <build>
-			<groupId>org.mockito</groupId>
+        <finalName>core-java-9</finalName>
-			<artifactId>mockito-core</artifactId>
-			<version>${mockito.version}</version>
-			<scope>test</scope>
-		</dependency>
 
-	</dependencies>
+        <plugins>
 
-	<build>
+            <plugin>
-		<finalName>core-java-9</finalName>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>1.9</source>
+                    <target>1.9</target>
+                </configuration>
+            </plugin>
 
-		<plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${maven-surefire-plugin.version}</version>
+            </plugin>
 
-			<plugin>
+        </plugins>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-compiler-plugin</artifactId>
-				<version>${maven-compiler-plugin.version}</version>
-				<configuration>
-					<source>1.9</source>
-					<target>1.9</target>
-					<verbose>true</verbose>
-				</configuration>
-			</plugin>
 
-			<plugin>
+    </build>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-surefire-plugin</artifactId>
-				<version>${maven-surefire-plugin.version}</version>
-			</plugin>
 
-		</plugins>
+    <properties>
+        <!-- project build encoding -->
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    
+        <!-- logging -->
+        <org.slf4j.version>1.7.21</org.slf4j.version>
 
-	</build>
+        <!-- maven plugins -->
+        <maven-compiler-plugin.version>3.6-jigsaw-SNAPSHOT</maven-compiler-plugin.version>
+        <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>
 
-	<properties>
+        <!-- testing -->
-		<!-- logging -->
+        <org.hamcrest.version>1.3</org.hamcrest.version>
-		<org.slf4j.version>1.7.21</org.slf4j.version>
+        <junit.version>4.12</junit.version>
-
+        <mockito.version>1.10.19</mockito.version>
-		<!-- maven plugins -->
+    </properties>
-		<maven-compiler-plugin.version>3.6-jigsaw-SNAPSHOT</maven-compiler-plugin.version>	
-		<maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>
-
-		<!-- testing -->
-		<org.hamcrest.version>1.3</org.hamcrest.version>
-		<junit.version>4.12</junit.version>
-		<mockito.version>1.10.19</mockito.version>
-	</properties>
 
 </project>

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

@@ -1,16 +1,16 @@
 package com.baeldung.java9.language;
 
 public interface PrivateInterface {
-    
+
     private static String staticPrivate() {
         return "static private";
     }
-    
+
     private String instancePrivate() {
         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(); 
+        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()
+        List<String> filteredList = listOfOptionals.stream().filter(Optional::isPresent).map(Optional::get).collect(Collectors.toList());
-          .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()
+        List<String> filteredList = listOfOptionals.stream().flatMap(o -> o.isPresent() ? Stream.of(o.get()) : Stream.empty()).collect(Collectors.toList());
-          .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()
+        List<String> filteredList = listOfOptionals.stream().flatMap(o -> o.map(Stream::of).orElseGet(Stream::empty)).collect(Collectors.toList());
-          .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()
+        List<String> filteredList = listOfOptionals.stream().flatMap(Optional::stream).collect(Collectors.toList());
-          .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

@@ -1,5 +1,5 @@
 package com.baeldung.java9;
-
+
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
 
@@ -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),
+        return new BufferedImage(getSize(i), getSize(i), BufferedImage.TYPE_INT_RGB);
-                BufferedImage.TYPE_INT_RGB);
     }
 
 }

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

@@ -1,6 +1,4 @@
-package com.baeldung.java9.httpclient;         
+package com.baeldung.java9.httpclient;
-
-
 
 import static java.net.HttpURLConnection.HTTP_OK;
 import static org.junit.Assert.assertTrue;
@@ -28,8 +26,8 @@ import org.junit.Test;
 
 public class SimpleHttpRequestsTest {
 
-   private URI httpURI; 
+    private URI httpURI;
-    
+
     @Before
     public void init() throws URISyntaxException {
         httpURI = new URI("http://www.baeldung.com/");
@@ -37,26 +35,26 @@ 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());
-        assertTrue("Get response status code is bigger then 400",  responseStatusCode < 400);
+        assertTrue("Get response status code is bigger then 400", responseStatusCode < 400);
     }
-    
+
     @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
     public void postMehtod() throws URISyntaxException, IOException, InterruptedException {
         HttpRequest.Builder requestBuilder = HttpRequest.create(httpURI);
@@ -66,61 +64,63 @@ public class SimpleHttpRequestsTest {
         int statusCode = response.statusCode();
         assertTrue("HTTP return code", statusCode == HTTP_OK);
     }
-    
+
     @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);
         HttpClient httpClient = hcBuilder.build();
         HttpRequest.Builder reqBuilder = httpClient.request(new URI("https://www.facebook.com"));
-        
+
         HttpRequest request = reqBuilder.followRedirects(HttpClient.Redirect.ALWAYS).GET();
         HttpResponse response = request.response();
         int statusCode = response.statusCode();
         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[] proto = sslP1.getApplicationProtocols();
-        String [] cifers = sslP1.getCipherSuites();
+        String[] cifers = sslP1.getCipherSuites();
         System.out.println(printStringArr(proto));
         System.out.println(printStringArr(cifers));
         return sslP1;
     }
-    
+
-    String printStringArr(String ... args ){
+    String printStringArr(String... args) {
-        if(args == null){
+        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){
+    String printHeaders(HttpHeaders h) {
-        if(h == null){
+        if (h == null) {
             return null;
         }
-        
+
-       StringBuilder sb = new StringBuilder();
+        StringBuilder sb = new StringBuilder();
-       Map<String, List<String>> hMap = h.map();
+        Map<String, List<String>> hMap = h.map();
-       for(String k : hMap.keySet()){
+        for (String k : hMap.keySet()) {
-           sb.append(k).append(":");
+            sb.append(k).append(":");
-           List<String> l =  hMap.get(k);
+            List<String> l = hMap.get(k);
-           if( l != null ){
+            if (l != null) {
-               l.forEach( s -> { sb.append(s).append(","); } );
+                l.forEach(s -> {
-           }
+                    sb.append(s).append(",");
-           sb.append("\n");
+                });
-       }
+            }
-       return sb.toString();
+            sb.append("\n");
+        }
+        return sb.toString();
     }
 }

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
+            return Stream.iterate("", s -> s + "s").takeWhile(s -> s.length() < 10);
-                    .iterate("", s -> s + "s")
-                    .takeWhile(s -> s.length() < 10);
         }
 
         public Stream<String> getStreamAfterDropWhileOperation() {
-            return Stream
+            return Stream.iterate("", s -> s + "s").takeWhile(s -> s.length() < 10).dropWhile(s -> !s.contains("sssss"));
-                    .iterate("", s -> s + "s")
-                    .takeWhile(s -> s.length() < 10)
-                    .dropWhile(s -> !s.contains("sssss"));
         }
 
         @Test
@@ -72,25 +67,25 @@ public class StreamFeaturesTest {
 
     }
 
-    public  static class OfNullableTest {
+    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);
+                put("A", 10);
-        }};
+                put("C", 30);
+            }
+        };
 
         private Stream<Integer> getStreamWithOfNullable() {
-            return collection.stream()
+            return collection.stream().flatMap(s -> Stream.ofNullable(map.get(s)));
-                    .flatMap(s -> Stream.ofNullable(map.get(s)));
         }
 
         private Stream<Integer> getStream() {
-            return collection.stream()
+            return collection.stream().flatMap(s -> {
-                            .flatMap(s -> {
+                Integer temp = map.get(s);
-                                Integer temp = map.get(s);
+                return temp != null ? Stream.of(temp) : Stream.empty();
-                                return temp != null ? Stream.of(temp) : Stream.empty();
+            });
-                            });
         }
 
         private List<Integer> testOfNullableFrom(Stream<Integer> stream) {
@@ -107,10 +102,7 @@ public class StreamFeaturesTest {
         @Test
         public void testOfNullable() {
 
-            assertEquals(
+            assertEquals(testOfNullableFrom(getStream()), testOfNullableFrom(getStreamWithOfNullable()));
-                    testOfNullableFrom(getStream()),
-                    testOfNullableFrom(getStreamWithOfNullable())
-            );
 
         }
 

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

@@ -22,90 +22,89 @@ 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();
         Optional<String[]> args = procInfo.arguments();
-        Optional<String> cmd =  procInfo.commandLine();
+        Optional<String> cmd = procInfo.commandLine();
         Optional<Instant> startTime = procInfo.startInstant();
         Optional<Duration> cpuUsage = procInfo.totalCpuDuration();
 
         waistCPU();
-        System.out.println("Args "+ args);
+        System.out.println("Args " + args);
-        System.out.println("Command " +cmd.orElse("EmptyCmd"));
+        System.out.println("Command " + cmd.orElse("EmptyCmd"));
-        System.out.println("Start time: "+ startTime.get().toString());
+        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();
+        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");
             });
         });
-        
+
         Thread.sleep(10000);
-        
+
         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());
+            // System.out.println(sr.nextInt());
-            randArr.add( sr.nextInt() );
+            randArr.add(sr.nextInt());
         }
     }
 

core-java/.gitignore

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

core-java/README.md

@@ -46,3 +46,14 @@
 - [Grep in Java](http://www.baeldung.com/grep-in-java)
 - [Java - Combine Multiple Collections](http://www.baeldung.com/java-combine-multiple-collections)
 - [Simulated Annealing for Travelling Salesman Problem](http://www.baeldung.com/java-simulated-annealing-for-traveling-salesman)
+- [Slope One Algorithm: Collaborative Filtering Recommendation Systems](http://www.baeldung.com/java-collaborative-filtering-recommendations)
+- [Differences Between the Java WatchService API and the Apache Commons IO Monitor Library](http://www.baeldung.com/java-watchservice-vs-apache-commons-io-monitor-library)
+- [Pattern Search with Grep in Java](http://www.baeldung.com/grep-in-java)
+- [URL Encoding and Decoding in Java](http://www.baeldung.com/java-url-encoding-decoding)
+- [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

@@ -7,25 +7,24 @@ import com.baeldung.algorithms.slope_one.SlopeOne;
 
 public class RunAlgorithm {
 
-	public static void main(String[] args) {
+    public static void main(String[] args) {
-		Scanner in = new Scanner(System.in);
+        Scanner in = new Scanner(System.in);
-		System.out.println("Run algorithm:");
+        System.out.println("Run algorithm:");
-		System.out.println("1 - Simulated Annealing");
+        System.out.println("1 - Simulated Annealing");
-		System.out.println("2 - Slope One");
+        System.out.println("2 - Slope One");
-		int decision = in.nextInt();
+        int decision = in.nextInt();
-		switch (decision) {
+        switch (decision) {
-		case 1:
+        case 1:
-			System.out.println(
+            System.out.println("Optimized distance for travel: " + SimulatedAnnealing.simulateAnnealing(10, 10000, 0.9995));
-					"Optimized distance for travel: " + SimulatedAnnealing.simulateAnnealing(10, 10000, 0.9995));
+            break;
-			break;
+        case 2:
-		case 2:
+            SlopeOne.slopeOne(3);
-			SlopeOne.slopeOne(3);
+            break;
-			break;
+        default:
-		default:
+            System.out.println("Unknown option");
-			System.out.println("Unknown option");
+            break;
-			break;
+        }
-		}
+        in.close();
-		in.close();
+    }
-	}
 
 }

core-java/src/main/java/com/baeldung/algorithms/annealing/City.java

@@ -5,18 +5,18 @@ import lombok.Data;
 @Data
 public class City {
 
-	private int x;
+    private int x;
-	private int y;
+    private int y;
 
-	public City() {
+    public City() {
-		this.x = (int) (Math.random() * 500);
+        this.x = (int) (Math.random() * 500);
-		this.y = (int) (Math.random() * 500);
+        this.y = (int) (Math.random() * 500);
-	}
+    }
 
-	public double distanceToCity(City city) {
+    public double distanceToCity(City city) {
-		int x = Math.abs(getX() - city.getX());
+        int x = Math.abs(getX() - city.getX());
-		int y = Math.abs(getY() - city.getY());
+        int y = Math.abs(getY() - city.getY());
-		return Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
+        return Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
-	}
+    }
 
 }

core-java/src/main/java/com/baeldung/algorithms/annealing/SimulatedAnnealing.java

@@ -24,7 +24,7 @@ public class SimulatedAnnealing {
                 }
                 t *= coolingRate;
             } else {
-            	continue;
+                continue;
             }
             if (i % 100 == 0) {
                 System.out.println("Iteration #" + i);

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

@@ -11,26 +11,25 @@ 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"));
 
-	public static Map<User, HashMap<Item, Double>> initializeData(int numberOfUsers) {
+    protected static List<Item> items = Arrays.asList(new Item("Candy"), new Item("Drink"), new Item("Soda"), new Item("Popcorn"), new Item("Snacks"));
-		Map<User, HashMap<Item, Double>> data = new HashMap<>();
+
-		HashMap<Item, Double> newUser;
+    public static Map<User, HashMap<Item, Double>> initializeData(int numberOfUsers) {
-		Set<Item> newRecommendationSet;
+        Map<User, HashMap<Item, Double>> data = new HashMap<>();
-		for (int i = 0; i < numberOfUsers; i++) {
+        HashMap<Item, Double> newUser;
-			newUser = new HashMap<Item, Double>();
+        Set<Item> newRecommendationSet;
-			newRecommendationSet = new HashSet<>();
+        for (int i = 0; i < numberOfUsers; i++) {
-			for (int j = 0; j < 3; j++) {
+            newUser = new HashMap<Item, Double>();
-				newRecommendationSet.add(items.get((int) (Math.random() * 5)));
+            newRecommendationSet = new HashSet<>();
-			}
+            for (int j = 0; j < 3; j++) {
-			for (Item item : newRecommendationSet) {
+                newRecommendationSet.add(items.get((int) (Math.random() * 5)));
-				newUser.put(item, Math.random());
+            }
-			}
+            for (Item item : newRecommendationSet) {
-			data.put(new User("User " + i), newUser);
+                newUser.put(item, Math.random());
-		}
+            }
-		return data;
+            data.put(new User("User " + i), newUser);
-	}
+        }
+        return data;
+    }
 
 }

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

@@ -9,5 +9,5 @@ import lombok.NoArgsConstructor;
 @AllArgsConstructor
 public class Item {
 
-	private String itemName;
+    private String itemName;
 }

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

@@ -11,114 +11,114 @@ import java.util.Map.Entry;
  */
 public class SlopeOne {
 
-	private static Map<Item, Map<Item, Double>> diff = new HashMap<>();
+    private static Map<Item, Map<Item, Double>> diff = new HashMap<>();
-	private static Map<Item, Map<Item, Integer>> freq = new HashMap<>();
+    private static Map<Item, Map<Item, Integer>> freq = new HashMap<>();
-	private static Map<User, HashMap<Item, Double>> inputData;
+    private static Map<User, HashMap<Item, Double>> inputData;
-	private static Map<User, HashMap<Item, Double>> outputData = new HashMap<>();
+    private static Map<User, HashMap<Item, Double>> outputData = new HashMap<>();
 
-	public static void slopeOne(int numberOfUsers) {
+    public static void slopeOne(int numberOfUsers) {
-		inputData = InputData.initializeData(numberOfUsers);
+        inputData = InputData.initializeData(numberOfUsers);
-		System.out.println("Slope One - Before the Prediction\n");
+        System.out.println("Slope One - Before the Prediction\n");
-		buildDifferencesMatrix(inputData);
+        buildDifferencesMatrix(inputData);
-		System.out.println("\nSlope One - With Predictions\n");
+        System.out.println("\nSlope One - With Predictions\n");
-		predict(inputData);
+        predict(inputData);
-	}
+    }
 
-	/**
+    /**
-	 * Based on the available data, calculate the relationships between the
+     * Based on the available data, calculate the relationships between the
-	 * items and number of occurences
+     * items and number of occurences
-	 * 
+     * 
-	 * @param data
+     * @param data
-	 *            existing user data and their items' ratings
+     *            existing user data and their items' ratings
-	 */
+     */
-	private static void buildDifferencesMatrix(Map<User, HashMap<Item, Double>> data) {
+    private static void buildDifferencesMatrix(Map<User, HashMap<Item, Double>> data) {
-		for (HashMap<Item, Double> user : data.values()) {
+        for (HashMap<Item, Double> user : data.values()) {
-			for (Entry<Item, Double> e : user.entrySet()) {
+            for (Entry<Item, Double> e : user.entrySet()) {
-				if (!diff.containsKey(e.getKey())) {
+                if (!diff.containsKey(e.getKey())) {
-					diff.put(e.getKey(), new HashMap<Item, Double>());
+                    diff.put(e.getKey(), new HashMap<Item, Double>());
-					freq.put(e.getKey(), new HashMap<Item, Integer>());
+                    freq.put(e.getKey(), new HashMap<Item, Integer>());
-				}
+                }
-				for (Entry<Item, Double> e2 : user.entrySet()) {
+                for (Entry<Item, Double> e2 : user.entrySet()) {
-					int oldCount = 0;
+                    int oldCount = 0;
-					if (freq.get(e.getKey()).containsKey(e2.getKey())) {
+                    if (freq.get(e.getKey()).containsKey(e2.getKey())) {
-						oldCount = freq.get(e.getKey()).get(e2.getKey()).intValue();
+                        oldCount = freq.get(e.getKey()).get(e2.getKey()).intValue();
-					}
+                    }
-					double oldDiff = 0.0;
+                    double oldDiff = 0.0;
-					if (diff.get(e.getKey()).containsKey(e2.getKey())) {
+                    if (diff.get(e.getKey()).containsKey(e2.getKey())) {
-						oldDiff = diff.get(e.getKey()).get(e2.getKey()).doubleValue();
+                        oldDiff = diff.get(e.getKey()).get(e2.getKey()).doubleValue();
-					}
+                    }
-					double observedDiff = e.getValue() - e2.getValue();
+                    double observedDiff = e.getValue() - e2.getValue();
-					freq.get(e.getKey()).put(e2.getKey(), oldCount + 1);
+                    freq.get(e.getKey()).put(e2.getKey(), oldCount + 1);
-					diff.get(e.getKey()).put(e2.getKey(), oldDiff + observedDiff);
+                    diff.get(e.getKey()).put(e2.getKey(), oldDiff + observedDiff);
-				}
+                }
-			}
+            }
-		}
+        }
-		for (Item j : diff.keySet()) {
+        for (Item j : diff.keySet()) {
-			for (Item i : diff.get(j).keySet()) {
+            for (Item i : diff.get(j).keySet()) {
-				double oldValue = diff.get(j).get(i).doubleValue();
+                double oldValue = diff.get(j).get(i).doubleValue();
-				int count = freq.get(j).get(i).intValue();
+                int count = freq.get(j).get(i).intValue();
-				diff.get(j).put(i, oldValue / count);
+                diff.get(j).put(i, oldValue / count);
-			}
+            }
-		}
+        }
-		printData(data);
+        printData(data);
-	}
+    }
 
-	/**
+    /**
-	 * Based on existing data predict all missing ratings. If prediction is not
+     * Based on existing data predict all missing ratings. If prediction is not
-	 * possible, the value will be equal to -1
+     * possible, the value will be equal to -1
-	 * 
+     * 
-	 * @param data
+     * @param data
-	 *            existing user data and their items' ratings
+     *            existing user data and their items' ratings
-	 */
+     */
-	private static void predict(Map<User, HashMap<Item, Double>> data) {
+    private static void predict(Map<User, HashMap<Item, Double>> data) {
-		HashMap<Item, Double> uPred = new HashMap<Item, Double>();
+        HashMap<Item, Double> uPred = new HashMap<Item, Double>();
-		HashMap<Item, Integer> uFreq = new HashMap<Item, Integer>();
+        HashMap<Item, Integer> uFreq = new HashMap<Item, Integer>();
-		for (Item j : diff.keySet()) {
+        for (Item j : diff.keySet()) {
-			uFreq.put(j, 0);
+            uFreq.put(j, 0);
-			uPred.put(j, 0.0);
+            uPred.put(j, 0.0);
-		}
+        }
-		for (Entry<User, HashMap<Item, Double>> e : data.entrySet()) {
+        for (Entry<User, HashMap<Item, Double>> e : data.entrySet()) {
-			for (Item j : e.getValue().keySet()) {
+            for (Item j : e.getValue().keySet()) {
-				for (Item k : diff.keySet()) {
+                for (Item k : diff.keySet()) {
-					try {
+                    try {
-						double predictedValue = diff.get(k).get(j).doubleValue() + e.getValue().get(j).doubleValue();
+                        double predictedValue = diff.get(k).get(j).doubleValue() + e.getValue().get(j).doubleValue();
-						double finalValue = predictedValue * freq.get(k).get(j).intValue();
+                        double finalValue = predictedValue * freq.get(k).get(j).intValue();
-						uPred.put(k, uPred.get(k) + finalValue);
+                        uPred.put(k, uPred.get(k) + finalValue);
-						uFreq.put(k, uFreq.get(k) + freq.get(k).get(j).intValue());
+                        uFreq.put(k, uFreq.get(k) + freq.get(k).get(j).intValue());
-					} catch (NullPointerException e1) {
+                    } catch (NullPointerException e1) {
-					}
+                    }
-				}
+                }
-			}
+            }
-			HashMap<Item, Double> clean = new HashMap<Item, Double>();
+            HashMap<Item, Double> clean = new HashMap<Item, Double>();
-			for (Item j : uPred.keySet()) {
+            for (Item j : uPred.keySet()) {
-				if (uFreq.get(j) > 0) {
+                if (uFreq.get(j) > 0) {
-					clean.put(j, uPred.get(j).doubleValue() / uFreq.get(j).intValue());
+                    clean.put(j, uPred.get(j).doubleValue() / uFreq.get(j).intValue());
-				}
+                }
-			}
+            }
-			for (Item j : InputData.items) {
+            for (Item j : InputData.items) {
-				if (e.getValue().containsKey(j)) {
+                if (e.getValue().containsKey(j)) {
-					clean.put(j, e.getValue().get(j));
+                    clean.put(j, e.getValue().get(j));
-				} else {
+                } else {
-					clean.put(j, -1.0);
+                    clean.put(j, -1.0);
-				}
+                }
-			}
+            }
-			outputData.put(e.getKey(), clean);
+            outputData.put(e.getKey(), clean);
-		}
+        }
-		printData(outputData);
+        printData(outputData);
-	}
+    }
 
-	private static void printData(Map<User, HashMap<Item, Double>> data) {
+    private static void printData(Map<User, HashMap<Item, Double>> data) {
-		for (User user : data.keySet()) {
+        for (User user : data.keySet()) {
-			System.out.println(user.getUsername() + ":");
+            System.out.println(user.getUsername() + ":");
-			print(data.get(user));
+            print(data.get(user));
-		}
+        }
-	}
+    }
 
-	private static void print(HashMap<Item, Double> hashMap) {
+    private static void print(HashMap<Item, Double> hashMap) {
-		NumberFormat formatter = new DecimalFormat("#0.000");
+        NumberFormat formatter = new DecimalFormat("#0.000");
-		for (Item j : hashMap.keySet()) {
+        for (Item j : hashMap.keySet()) {
-			System.out.println(" " + j.getItemName() + " --> " + formatter.format(hashMap.get(j).doubleValue()));
+            System.out.println(" " + j.getItemName() + " --> " + formatter.format(hashMap.get(j).doubleValue()));
-		}
+        }
-	}
+    }
 
 }

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

@@ -8,7 +8,7 @@ import lombok.NoArgsConstructor;
 @NoArgsConstructor
 @AllArgsConstructor
 public class User {
-	
+
-	private String username;
+    private String username;
 
 }

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

@@ -10,13 +10,11 @@ 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/main/java/com/baeldung/scripting/Nashorn.java

@@ -1,48 +0,0 @@
-package com.baeldung.scripting;
-
-import javax.script.Bindings;
-import javax.script.Invocable;
-import javax.script.ScriptEngine;
-import javax.script.ScriptEngineManager;
-import javax.script.ScriptException;
-
-public class Nashorn {
-    public static void main(String[] args) throws ScriptException, NoSuchMethodException {
-        ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
-
-        Object result = engine.eval(
-                "var greeting='hello world';" +
-                        "print(greeting);" +
-                        "greeting");
-
-        System.out.println(result);
-
-        Bindings bindings = engine.createBindings();
-        bindings.put("count", 3);
-        bindings.put("name", "baeldung");
-
-        String script = "var greeting='Hello ';" +
-                "for(var i=count;i>0;i--) { " +
-                "greeting+=name + ' '" +
-                "}" +
-                "greeting";
-
-        Object bindingsResult = engine.eval(script, bindings);
-        System.out.println(bindingsResult);
-
-        engine.eval("function composeGreeting(name) {" +
-                "return 'Hello ' + name" +
-                "}");
-        Invocable invocable = (Invocable) engine;
-
-        Object funcResult = invocable.invokeFunction("composeGreeting", "baeldung");
-        System.out.println(funcResult);
-
-        Object map = engine.eval("var HashMap = Java.type('java.util.HashMap');" +
-                "var map = new HashMap();" +
-                "map.put('hello', 'world');" +
-                "map");
-
-        System.out.println(map);
-    }
-}

core-java/src/main/resources/js/bind.js

@@ -0,0 +1,15 @@
+var first = {
+    name: "Whiskey",
+    age: 5
+};
+
+var second = {
+    volume: 100
+};
+
+Object.bindProperties(first, second);
+
+print(first.volume);
+
+second.volume = 1000;
+print(first.volume);

core-java/src/main/resources/js/locations.js

@@ -0,0 +1 @@
+print(__FILE__, __LINE__, __DIR__);

core-java/src/main/resources/js/math_module.js

@@ -0,0 +1,19 @@
+var math = {
+    increment: function (num) {
+        return ++num;
+    },
+
+    failFunc: function () {
+        try {
+            throw "BOOM";
+        } catch (e if typeof e === 'string') {
+            print("String thrown: " + e);
+        }
+        catch (e) {
+            print("this shouldn't happen!");
+        }
+    }
+};
+
+
+math;

core-java/src/main/resources/js/no_such.js

@@ -0,0 +1,11 @@
+var demo = {
+    __noSuchProperty__: function (propName) {
+        print("Accessed non-existing property: " + propName);
+    },
+
+    __noSuchMethod__: function (methodName) {
+        print("Invoked non-existing method: " + methodName);
+    }
+};
+
+demo;

core-java/src/main/resources/js/script.js

@@ -0,0 +1 @@
+function increment(num) ++num;

core-java/src/main/resources/js/trim.js

@@ -0,0 +1,2 @@
+print("   hello world".trimLeft());
+print("hello world     ".trimRight());

core-java/src/main/resources/js/typed_arrays.js

@@ -0,0 +1,9 @@
+function arrays(arr) {
+
+    var javaIntArray = Java.to(arr, "int[]");
+    print(javaIntArray[0]);
+    print(javaIntArray[1]);
+    print(javaIntArray[2]);
+}
+
+arrays([100, "1654", true]);

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);
+}
+
+}