resolve conflict

.gitignore

@@ -33,3 +33,11 @@ spring-openid/src/main/resources/application.properties
 spring-security-openid/src/main/resources/application.properties
 
 spring-all/*.log
+
+*.jar
+
+SpringDataInjectionDemo/.mvn/wrapper/maven-wrapper.properties
+
+spring-call-getters-using-reflection/.mvn/wrapper/maven-wrapper.properties
+
+spring-check-if-a-property-is-null/.mvn/wrapper/maven-wrapper.properties

algorithms/README.md

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

algorithms/src/main/java/com/baeldung/algorithms/hillclimbing/HillClimbing.java

@@ -186,4 +186,4 @@ public class HillClimbing {
         return stackHeuristics;
     }
 
-}
+}

algorithms/src/main/java/com/baeldung/algorithms/hillclimbing/State.java

@@ -40,4 +40,4 @@ public class State {
     public void setHeuristics(int heuristics) {
         this.heuristics = heuristics;
     }
-}
+}

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

@@ -0,0 +1,14 @@
+package com.baeldung.algorithms.minimax;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+class GameOfBones {
+    static List<Integer> getPossibleStates(int noOfBonesInHeap) {
+        return IntStream.rangeClosed(1, 3).boxed()
+          .map(i -> noOfBonesInHeap - i)
+          .filter(newHeapCount -> newHeapCount >= 0)
+          .collect(Collectors.toList());
+    }
+}

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

@@ -0,0 +1,60 @@
+package com.baeldung.algorithms.minimax;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+public class MiniMax {
+    private Tree tree;
+
+    public Tree getTree() {
+        return tree;
+    }
+
+    public void constructTree(int noOfBones) {
+        tree = new Tree();
+        Node root = new Node(noOfBones, true);
+        tree.setRoot(root);
+        constructTree(root);
+    }
+
+    private void constructTree(Node parentNode) {
+        List<Integer> listofPossibleHeaps = GameOfBones.getPossibleStates(parentNode.getNoOfBones());
+        boolean isChildMaxPlayer = !parentNode.isMaxPlayer();
+        listofPossibleHeaps.forEach(n -> {
+            Node newNode = new Node(n, isChildMaxPlayer);
+            parentNode.addChild(newNode);
+            if (newNode.getNoOfBones() > 0) {
+                constructTree(newNode);
+            }
+        });
+    }
+
+    public boolean checkWin() {
+        Node root = tree.getRoot();
+        checkWin(root);
+        return root.getScore() == 1;
+    }
+
+    private void checkWin(Node node) {
+        List<Node> children = node.getChildren();
+        boolean isMaxPlayer = node.isMaxPlayer();
+        children.forEach(child -> {
+            if (child.getNoOfBones() == 0) {
+                child.setScore(isMaxPlayer ? 1 : -1);
+            } else {
+                checkWin(child);
+            }
+        });
+        Node bestChild = findBestChild(isMaxPlayer, children);
+        node.setScore(bestChild.getScore());
+    }
+
+    private Node findBestChild(boolean isMaxPlayer, List<Node> children) {
+        Comparator<Node> byScoreComparator = Comparator.comparing(Node::getScore);
+
+        return children.stream()
+          .max(isMaxPlayer ? byScoreComparator : byScoreComparator.reversed())
+          .orElseThrow(NoSuchElementException::new);
+    }
+}

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

@@ -0,0 +1,42 @@
+package com.baeldung.algorithms.minimax;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Node {
+    private int noOfBones;
+    private boolean isMaxPlayer;
+    private int score;
+    private List<Node> children;
+
+    public Node(int noOfBones, boolean isMaxPlayer) {
+        this.noOfBones = noOfBones;
+        this.isMaxPlayer = isMaxPlayer;
+        children = new ArrayList<>();
+    }
+
+    int getNoOfBones() {
+        return noOfBones;
+    }
+
+    boolean isMaxPlayer() {
+        return isMaxPlayer;
+    }
+
+    int getScore() {
+        return score;
+    }
+
+    void setScore(int score) {
+        this.score = score;
+    }
+
+    List<Node> getChildren() {
+        return children;
+    }
+
+    void addChild(Node newNode) {
+        children.add(newNode);
+    }
+
+}

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

@@ -0,0 +1,16 @@
+package com.baeldung.algorithms.minimax;
+
+public class Tree {
+    private Node root;
+
+    Tree() {
+    }
+
+    Node getRoot() {
+        return root;
+    }
+
+    void setRoot(Node root) {
+        this.root = root;
+    }
+}

algorithms/src/test/java/algorithms/HillClimbingAlgorithmTest.java

@@ -55,4 +55,4 @@ public class HillClimbingAlgorithmTest {
         State nextState = hillClimbing.findNextState(currentState, goalStack);
         assertTrue(nextState.getHeuristics() > currentState.getHeuristics());
     }
-}
+}

algorithms/src/test/java/algorithms/MCTSTest.java

@@ -0,0 +1,92 @@
+package algorithms;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.baeldung.algorithms.mcts.montecarlo.MonteCarloTreeSearch;
+import com.baeldung.algorithms.mcts.montecarlo.State;
+import com.baeldung.algorithms.mcts.montecarlo.UCT;
+import com.baeldung.algorithms.mcts.tictactoe.Board;
+import com.baeldung.algorithms.mcts.tictactoe.Position;
+import com.baeldung.algorithms.mcts.tree.Tree;
+
+public class MCTSTest {
+    Tree gameTree;
+    MonteCarloTreeSearch mcts;
+
+    @Before
+    public void initGameTree() {
+        gameTree = new Tree();
+        mcts = new MonteCarloTreeSearch();
+    }
+
+    @Test
+    public void givenStats_whenGetUCTForNode_thenUCTMatchesWithManualData() {
+        double uctValue = 15.79;
+        assertEquals(UCT.uctValue(600, 300, 20), uctValue, 0.01);
+    }
+
+    @Test
+    public void giveninitBoardState_whenGetAllPossibleStates_thenNonEmptyList() {
+        State initState = gameTree.getRoot().getState();
+        List<State> possibleStates = initState.getAllPossibleStates();
+        assertTrue(possibleStates.size() > 0);
+    }
+
+    @Test
+    public void givenEmptyBoard_whenPerformMove_thenLessAvailablePossitions() {
+        Board board = new Board();
+        int initAvailablePositions = board.getEmptyPositions().size();
+        board.performMove(Board.P1, new Position(1, 1));
+        int availablePositions = board.getEmptyPositions().size();
+        assertTrue(initAvailablePositions > availablePositions);
+    }
+
+    @Test
+    public void givenEmptyBoard_whenSimulateInterAIPlay_thenGameDraw() {
+        Board board = new Board();
+
+        int player = Board.P1;
+        int totalMoves = Board.DEFAULT_BOARD_SIZE * Board.DEFAULT_BOARD_SIZE;
+        for (int i = 0; i < totalMoves; i++) {
+            board = mcts.findNextMove(board, player);
+            if (board.checkStatus() != -1) {
+                break;
+            }
+            player = 3 - player;
+        }
+        int winStatus = board.checkStatus();
+        assertEquals(winStatus, Board.DRAW);
+    }
+
+    @Test
+    public void givenEmptyBoard_whenLevel1VsLevel3_thenLevel3WinsOrDraw() {
+        Board board = new Board();
+        MonteCarloTreeSearch mcts1 = new MonteCarloTreeSearch();
+        mcts1.setLevel(1);
+        MonteCarloTreeSearch mcts3 = new MonteCarloTreeSearch();
+        mcts3.setLevel(3);
+
+        int player = Board.P1;
+        int totalMoves = Board.DEFAULT_BOARD_SIZE * Board.DEFAULT_BOARD_SIZE;
+        for (int i = 0; i < totalMoves; i++) {
+            if (player == Board.P1)
+                board = mcts3.findNextMove(board, player);
+            else
+                board = mcts1.findNextMove(board, player);
+
+            if (board.checkStatus() != -1) {
+                break;
+            }
+            player = 3 - player;
+        }
+        int winStatus = board.checkStatus();
+        assertTrue(winStatus == Board.DRAW || winStatus == Board.P1);
+    }
+
+}

algorithms/src/test/java/algorithms/minimax/MinimaxTest.java

@@ -0,0 +1,36 @@
+package algorithms.minimax;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+import com.baeldung.algorithms.minimax.MiniMax;
+import com.baeldung.algorithms.minimax.Tree;
+
+public class MinimaxTest {
+    private Tree gameTree;
+    private MiniMax miniMax;
+
+    @Before
+    public void initMiniMaxUtility() {
+        miniMax = new MiniMax();
+    }
+
+    @Test
+    public void givenMiniMax_whenConstructTree_thenNotNullTree() {
+        assertNull(gameTree);
+        miniMax.constructTree(6);
+        gameTree = miniMax.getTree();
+        assertNotNull(gameTree);
+    }
+
+    @Test
+    public void givenMiniMax_whenCheckWin_thenComputeOptimal() {
+        miniMax.constructTree(6);
+        boolean result = miniMax.checkWin();
+        assertTrue(result);
+        miniMax.constructTree(8);
+        result = miniMax.checkWin();
+        assertFalse(result);
+    }
+}

aws/pom.xml

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

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

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

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

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

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

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

core-java-9/README.md

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

core-java/README.md

@@ -113,6 +113,16 @@
 - [Difference Between Wait and Sleep in Java](http://www.baeldung.com/java-wait-and-sleep)
 - [LongAdder and LongAccumulator in Java](http://www.baeldung.com/java-longadder-and-longaccumulator)
 - [Using Java MappedByteBuffer](http://www.baeldung.com/java-mapped-byte-buffer)
+- [The Dining Philosophers Problem in Java](http://www.baeldung.com/java-dining-philoshophers)
+- [The Difference Between map() and flatMap()](http://www.baeldung.com/java-difference-map-and-flatmap)
+- [How to Round a Number to N Decimal Places in Java](http://www.baeldung.com/java-round-decimal-number)
+- [Changing Annotation Parameters At Runtime](http://www.baeldung.com/java-reflection-change-annotation-params)
+- [How to Find all Getters Returning Null](http://www.baeldung.com/java-getters-returning-null)
+- [Converting String to Stream of chars](http://www.baeldung.com/java-string-to-stream)
+- [Changing the Order in a Sum Operation Can Produce Different Results?](http://www.baeldung.com/java-floating-point-sum-order)
+- [How to Get a Name of a Method Being Executed?](http://www.baeldung.com/java-name-of-executing-method)
+- [Iterate over a Map in Java](http://www.baeldung.com/java-iterate-map)
+- [CyclicBarrier in Java](http://www.baeldung.com/java-cyclic-barrier)
 - [Dynamic Proxies in Java](http://www.baeldung.com/java-dynamic-proxies)
 - [How to Copy an Array in Java](http://www.baeldung.com/java-array-copy)
 - [Introduction to JDBC](http://www.baeldung.com/java-jdbc)

core-java/pom.xml

@@ -417,4 +417,4 @@
         <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>
 
     </properties>
-</project>
+</project>

core-java/src/main/java/com/baeldung/deserialization/AppleProduct.java

@@ -0,0 +1,26 @@
+package com.baeldung.deserialization;
+
+import java.io.Serializable;
+
+public class AppleProduct implements Serializable {
+
+     private static final long serialVersionUID = 1234567L; // user-defined (i.e. not default or generated)
+//    private static final long serialVersionUID = 7654321L; // user-defined (i.e. not default or generated)
+
+    public String headphonePort;
+    public String thunderboltPort;
+    public String lighteningPort;
+
+    public String getHeadphonePort() {
+        return headphonePort;
+    }
+
+    public String getThunderboltPort() {
+        return thunderboltPort;
+    }
+
+    public static long getSerialVersionUID() {
+        return serialVersionUID;
+    }
+
+}

core-java/src/main/java/com/baeldung/deserialization/DeserializationUtility.java

@@ -0,0 +1,27 @@
+package com.baeldung.deserialization;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.util.Base64;
+
+public class DeserializationUtility {
+
+    public static void main(String[] args) throws ClassNotFoundException, IOException {
+
+        String serializedObj = "rO0ABXNyACljb20uYmFlbGR1bmcuZGVzZXJpYWxpemF0aW9uLkFwcGxlUHJvZHVjdAAAAAAAEtaHAgADTAANaGVhZHBob25lUG9ydHQAEkxqYXZhL2xhbmcvU3RyaW5nO0wADmxpZ2h0ZW5pbmdQb3J0cQB+AAFMAA90aHVuZGVyYm9sdFBvcnRxAH4AAXhwdAARaGVhZHBob25lUG9ydDIwMjBwdAATdGh1bmRlcmJvbHRQb3J0MjAyMA==";
+        System.out.println("Deserializing AppleProduct...");
+        AppleProduct deserializedObj = (AppleProduct) deSerializeObjectFromString(serializedObj);
+        System.out.println("Headphone port of AppleProduct:" + deserializedObj.getHeadphonePort());
+        System.out.println("Thunderbolt port of AppleProduct:" + deserializedObj.getThunderboltPort());
+    }
+
+    public static Object deSerializeObjectFromString(String s) throws IOException, ClassNotFoundException {
+        byte[] data = Base64.getDecoder().decode(s);
+        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(data));
+        Object o = ois.readObject();
+        ois.close();
+        return o;
+    }
+
+}

core-java/src/main/java/com/baeldung/deserialization/SerializationUtility.java

@@ -0,0 +1,30 @@
+package com.baeldung.deserialization;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.Base64;
+
+public class SerializationUtility {
+
+    public static void main(String[] args) throws ClassNotFoundException, IOException {
+
+        AppleProduct macBook = new AppleProduct();
+        macBook.headphonePort = "headphonePort2020";
+        macBook.thunderboltPort = "thunderboltPort2020";
+
+        String serializedObj = serializeObjectToString(macBook);
+        System.out.println("Serialized AppleProduct object to string:");
+        System.out.println(serializedObj);
+    }
+
+    public static String serializeObjectToString(Serializable o) throws IOException {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        ObjectOutputStream oos = new ObjectOutputStream(baos);
+        oos.writeObject(o);
+        oos.close();
+        return Base64.getEncoder().encodeToString(baos.toByteArray());
+    }
+
+}

core-java/src/main/java/com/baeldung/javanetworking/uriurl/URIDemo.java

@@ -0,0 +1,91 @@
+package com.baeldung.javanetworking.uriurl;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class URIDemo {
+    private final Logger logger = LoggerFactory.getLogger(URIDemo.class);
+
+    String URISTRING = "https://wordpress.org:443/support/topic/page-jumps-within-wordpress/?replies=3#post-2278484";
+    // parsed locator
+    String URISCHEME = "https";
+    String URISCHEMESPECIFIC;
+    String URIHOST = "wordpress.org";
+    String URIAUTHORITY = "wordpress.org:443";
+
+    String URIPATH = "/support/topic/page-jumps-within-wordpress/";
+    int URIPORT = 443;
+    String URIQUERY = "replies=3";
+    String URIFRAGMENT = "post-2278484";
+    String URIUSERINFO;
+    String URICOMPOUND = URISCHEME + "://" + URIHOST + ":" + URIPORT + URIPATH + "?" + URIQUERY + "#" + URIFRAGMENT;
+
+    URI uri;
+    URL url;
+    BufferedReader in = null;
+    String URIContent = "";
+
+    private String getParsedPieces(URI uri) {
+        logger.info("*** List of parsed pieces ***");
+        URISCHEME = uri.getScheme();
+        logger.info("URISCHEME: " + URISCHEME);
+        URISCHEMESPECIFIC = uri.getSchemeSpecificPart();
+        logger.info("URISCHEMESPECIFIC: " + URISCHEMESPECIFIC);
+        URIHOST = uri.getHost();
+        URIAUTHORITY = uri.getAuthority();
+        logger.info("URIAUTHORITY: " + URIAUTHORITY);
+        logger.info("URIHOST: " + URIHOST);
+        URIPATH = uri.getPath();
+        logger.info("URIPATH: " + URIPATH);
+        URIPORT = uri.getPort();
+        logger.info("URIPORT: " + URIPORT);
+        URIQUERY = uri.getQuery();
+        logger.info("URIQUERY: " + URIQUERY);
+        URIFRAGMENT = uri.getFragment();
+        logger.info("URIFRAGMENT: " + URIFRAGMENT);
+
+        try {
+            url = uri.toURL();
+        } catch (MalformedURLException e) {
+            logger.info("MalformedURLException thrown: " + e.getMessage());
+            e.printStackTrace();
+        } catch (IllegalArgumentException e) {
+            logger.info("IllegalArgumentException thrown: " + e.getMessage());
+            e.printStackTrace();
+        }
+        return url.toString();
+    }
+
+    public String testURIAsNew(String URIString) {
+        // creating URI object
+        try {
+            uri = new URI(URIString);
+        } catch (URISyntaxException e) {
+            logger.info("URISyntaxException thrown: " + e.getMessage());
+            e.printStackTrace();
+            throw new IllegalArgumentException();
+        }
+        return getParsedPieces(uri);
+    }
+
+    public String testURIAsCreate(String URIString) {
+        // creating URI object
+        uri = URI.create(URIString);
+        return getParsedPieces(uri);
+    }
+
+    public static void main(String[] args) throws Exception {
+        URIDemo demo = new URIDemo();
+        String contentCreate = demo.testURIAsCreate(demo.URICOMPOUND);
+        demo.logger.info(contentCreate);
+        String contentNew = demo.testURIAsNew(demo.URICOMPOUND);
+        demo.logger.info(contentNew);
+    }
+}

core-java/src/main/java/com/baeldung/javanetworking/uriurl/URLDemo.java

@@ -1,9 +1,10 @@
-package com.baeldung.javanetworking.url;
+package com.baeldung.javanetworking.uriurl;
 
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.net.HttpURLConnection;
+import java.net.URI;
 import java.net.URL;
 import java.net.URLConnection;
 

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

@@ -11,4 +11,4 @@ public class NoClassDefFoundErrorExample {
         test = new ClassWithInitErrors();
         return test;
     }
-}
+}

core-java/src/main/java/com/baeldung/temporaladjuster/CustomTemporalAdjuster.java

@@ -0,0 +1,23 @@
+package com.baeldung.temporaladjuster;
+
+import java.time.DayOfWeek;
+import java.time.temporal.ChronoField;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAdjuster;
+
+public class CustomTemporalAdjuster implements TemporalAdjuster {
+
+    @Override
+    public Temporal adjustInto(Temporal temporal) {
+        DayOfWeek dayOfWeek = DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK));
+        int daysToAdd;
+        if (dayOfWeek == DayOfWeek.FRIDAY)
+            daysToAdd = 3;
+        else if (dayOfWeek == DayOfWeek.SATURDAY)
+            daysToAdd = 2;
+        else
+            daysToAdd = 1;
+        return temporal.plus(daysToAdd, ChronoUnit.DAYS);
+    }
+}

core-java/src/test/java/com/baeldung/arraycopy/ArrayCopyUtilUnitTest.java

@@ -9,6 +9,8 @@ import org.junit.Test;
 
 import java.util.Arrays;
 
+import static org.junit.Assert.assertTrue;
+
 public class ArrayCopyUtilUnitTest {
     private static Employee[] employees;
     private static final int MAX = 2;
@@ -46,10 +48,10 @@ public class ArrayCopyUtilUnitTest {
         
         System.arraycopy(array, 2, copiedArray, 0, 3);
         
-        Assert.assertTrue(3 == copiedArray.length);
-        Assert.assertTrue(copiedArray[0] == array[2]);
-        Assert.assertTrue(copiedArray[1] == array[3]);
-        Assert.assertTrue(copiedArray[2] == array[4]);
+        assertTrue(3 == copiedArray.length);
+        assertTrue(copiedArray[0] == array[2]);
+        assertTrue(copiedArray[1] == array[3]);
+        assertTrue(copiedArray[2] == array[4]);
     }
 
     @Test
@@ -58,10 +60,10 @@ public class ArrayCopyUtilUnitTest {
         
         int[] copiedArray = Arrays.copyOfRange(array, 1, 4);
         
-        Assert.assertTrue(3 == copiedArray.length);
-        Assert.assertTrue(copiedArray[0] == array[1]);
-        Assert.assertTrue(copiedArray[1] == array[2]);
-        Assert.assertTrue(copiedArray[2] == array[3]);
+        assertTrue(3 == copiedArray.length);
+        assertTrue(copiedArray[0] == array[1]);
+        assertTrue(copiedArray[1] == array[2]);
+        assertTrue(copiedArray[2] == array[3]);
     }
 
     @Test
@@ -73,9 +75,9 @@ public class ArrayCopyUtilUnitTest {
         
         Assert.assertArrayEquals(copiedArray, array);
         array[0] = 9;
-        Assert.assertTrue(copiedArray[0] != array[0]);
+        assertTrue(copiedArray[0] != array[0]);
         copiedArray[1] = 12;
-        Assert.assertTrue(copiedArray[1] != array[1]);
+        assertTrue(copiedArray[1] != array[1]);
     }
 
     @Test
@@ -85,7 +87,7 @@ public class ArrayCopyUtilUnitTest {
         Assert.assertArrayEquals(copiedArray, employees);
         employees[0].setName(employees[0].getName()+"_Changed");
         //change in employees' element caused change in the copied array
-        Assert.assertTrue(copiedArray[0].getName().equals(employees[0].getName()));
+        assertTrue(copiedArray[0].getName().equals(employees[0].getName()));
     }
 
     @Test
@@ -96,9 +98,9 @@ public class ArrayCopyUtilUnitTest {
         
         Assert.assertArrayEquals(copiedArray, array);
         array[0] = 9;
-        Assert.assertTrue(copiedArray[0] != array[0]);
+        assertTrue(copiedArray[0] != array[0]);
         copiedArray[1] = 12;
-        Assert.assertTrue(copiedArray[1] != array[1]);
+        assertTrue(copiedArray[1] != array[1]);
     }
 
     @Test
@@ -108,7 +110,7 @@ public class ArrayCopyUtilUnitTest {
         Assert.assertArrayEquals(copiedArray, employees);;
         employees[0].setName(employees[0].getName()+"_Changed");
         //change in employees' element changed the copied array
-        Assert.assertTrue(copiedArray[0].getName().equals(employees[0].getName()));
+        assertTrue(copiedArray[0].getName().equals(employees[0].getName()));
     }
 
     @Test
@@ -138,7 +140,7 @@ public class ArrayCopyUtilUnitTest {
         Assert.assertArrayEquals(copiedArray, employees);
         employees[0].setName(employees[0].getName()+"_Changed");
         //change in employees' element didn't change in the copied array
-        Assert.assertTrue(copiedArray[0].getName().equals(employees[0].getName()));
+        assertTrue(copiedArray[0].getName().equals(employees[0].getName()));
     }
     
     @Test

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

@@ -8,4 +8,4 @@ public class ClassNotFoundExceptionTest {
     public void givenNoDriversInClassPath_whenLoadDrivers_thenClassNotFoundException() throws ClassNotFoundException {
         Class.forName("oracle.jdbc.driver.OracleDriver");
     }
-}
+}

core-java/src/test/java/com/baeldung/completablefuture/CompletableFutureLongRunningUnitTest.java

@@ -24,7 +24,7 @@ public class CompletableFutureLongRunningUnitTest {
         assertEquals("Hello", result);
     }
 
-    public Future<String> calculateAsync() throws InterruptedException {
+    private Future<String> calculateAsync() throws InterruptedException {
         CompletableFuture<String> completableFuture = new CompletableFuture<>();
 
         Executors.newCachedThreadPool().submit(() -> {
@@ -44,7 +44,7 @@ public class CompletableFutureLongRunningUnitTest {
         assertEquals("Hello", result);
     }
 
-    public Future<String> calculateAsyncWithCancellation() throws InterruptedException {
+    private Future<String> calculateAsyncWithCancellation() throws InterruptedException {
         CompletableFuture<String> completableFuture = new CompletableFuture<>();
 
         Executors.newCachedThreadPool().submit(() -> {

core-java/src/test/java/com/baeldung/concurrent/accumulator/LongAccumulatorUnitTest.java

@@ -24,8 +24,8 @@ public class LongAccumulatorUnitTest {
 
         //when
         Runnable accumulateAction = () -> IntStream
-                .rangeClosed(0, numberOfIncrements)
-                .forEach(accumulator::accumulate);
+          .rangeClosed(0, numberOfIncrements)
+          .forEach(accumulator::accumulate);
 
         for (int i = 0; i < numberOfThreads; i++) {
             executorService.execute(accumulateAction);

core-java/src/test/java/com/baeldung/concurrent/copyonwrite/CopyOnWriteArrayListUnitTest.java

@@ -17,7 +17,7 @@ public class CopyOnWriteArrayListUnitTest {
     public void givenCopyOnWriteList_whenIterateAndAddElementToUnderneathList_thenShouldNotChangeIterator() {
         //given
         final CopyOnWriteArrayList<Integer> numbers =
-                new CopyOnWriteArrayList<>(new Integer[]{1, 3, 5, 8});
+          new CopyOnWriteArrayList<>(new Integer[]{1, 3, 5, 8});
 
         //when
         Iterator<Integer> iterator = numbers.iterator();
@@ -42,7 +42,7 @@ public class CopyOnWriteArrayListUnitTest {
     public void givenCopyOnWriteList_whenIterateOverItAndTryToRemoveElement_thenShouldThrowException() {
         //given
         final CopyOnWriteArrayList<Integer> numbers =
-                new CopyOnWriteArrayList<>(new Integer[]{1, 3, 5, 8});
+          new CopyOnWriteArrayList<>(new Integer[]{1, 3, 5, 8});
 
         //when
         Iterator<Integer> iterator = numbers.iterator();